home *** CD-ROM | disk | FTP | other *** search
/ NeXTSTEP 3.3 (Developer)…68k, x86, SPARC, PA-RISC] / NeXTSTEP 3.3 Dev Intel.iso / NextDeveloper / Source / GNU / cc / cp-call.c < prev    next >
C/C++ Source or Header  |  1993-12-02  |  120KB  |  4,119 lines
  1. /* Functions related to invoking methods and overloaded functions.
  2.    Copyright (C) 1987, 1992, 1993 Free Software Foundation, Inc.
  3.    Contributed by Michael Tiemann (tiemann@cygnus.com) and
  4.    hacked by Brendan Kehoe (brendan@cygnus.com).
  5.  
  6. This file is part of GNU CC.
  7.  
  8. GNU CC is free software; you can redistribute it and/or modify
  9. it under the terms of the GNU General Public License as published by
  10. the Free Software Foundation; either version 2, or (at your option)
  11. any later version.
  12.  
  13. GNU CC is distributed in the hope that it will be useful,
  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU General Public License for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with GNU CC; see the file COPYING.  If not, write to
  20. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21.  
  22.  
  23. /* High-level class interface. */
  24.  
  25. #include "config.h"
  26. #include "tree.h"
  27. #include <stdio.h>
  28. #include "cp-tree.h"
  29. #include "cp-class.h"
  30. #include "flags.h"
  31.  
  32. #include "obstack.h"
  33. #define obstack_chunk_alloc xmalloc
  34. #define obstack_chunk_free free
  35.  
  36. extern void sorry ();
  37.  
  38. extern int inhibit_warnings;
  39. extern int flag_assume_nonnull_objects;
  40. extern tree ctor_label, dtor_label;
  41.  
  42. /* From cp-typeck.c:  */
  43. extern tree unary_complex_lvalue ();
  44.  
  45. /* Compute the ease with which a conversion can be performed
  46.    between an expected and the given type.  */
  47. static int convert_harshness_old ();
  48. static struct harshness_code convert_harshness_ansi ();
  49.  
  50. /* OLD METHOD */
  51. /* Note the old method also uses USER_HARSHNESS, BASE_DERIVED_HARSHNESS,
  52.    CONST_HARSHNESS.  */
  53. #define EVIL 1
  54. #define TRIVIAL 0
  55. #define EVIL_HARSHNESS(ARG) ((ARG) & 1)
  56. #define ELLIPSIS_HARSHNESS(ARG) ((ARG) & 2)
  57. #define CONTRAVARIANT_HARSHNESS(ARG) ((ARG) & 8)
  58. #define INT_TO_BD_HARSHNESS(ARG) (((ARG) << 5) | 16)
  59. #define INT_FROM_BD_HARSHNESS(ARG) ((ARG) >> 5)
  60. #define INT_TO_EASY_HARSHNESS(ARG) ((ARG) << 5)
  61. #define INT_FROM_EASY_HARSHNESS(ARG) ((ARG) >> 5)
  62. #define ONLY_EASY_HARSHNESS(ARG) (((ARG) & 31) == 0)
  63.  
  64.  
  65. /* NEW METHOD */
  66. #define EVIL_RETURN(ARG)    ((ARG).code = EVIL_CODE, (ARG))
  67. #define QUAL_RETURN(ARG)    ((ARG).code = QUAL_CODE, (ARG))
  68. #define TRIVIAL_RETURN(ARG)    ((ARG).code = TRIVIAL_CODE, (ARG))
  69. #define ZERO_RETURN(ARG)    ((ARG).code = 0, (ARG))
  70.  
  71. #define USER_HARSHNESS(ARG) ((ARG) & 4)
  72. #define BASE_DERIVED_HARSHNESS(ARG) ((ARG) & 16)
  73. #define CONST_HARSHNESS(ARG) ((ARG) & 2048)
  74.  
  75. /* Ordering function for overload resolution.  Compare two candidates
  76.    by gross quality.  */
  77. int
  78. rank_for_overload_ansi (x, y)
  79.      struct candidate *x, *y;
  80. {
  81.   if (y->h.code & (EVIL_CODE|ELLIPSIS_CODE|USER_CODE))
  82.     return y->h.code - x->h.code;
  83.   if (x->h.code & (EVIL_CODE|ELLIPSIS_CODE|USER_CODE))
  84.     return -1;
  85.  
  86.   /* This is set by compute_conversion_costs, for calling a non-const
  87.      member function from a const member function.  */
  88.   if ((y->v.ansi_harshness[0].code & CONST_CODE) ^ (x->v.ansi_harshness[0].code & CONST_CODE))
  89.     return y->v.ansi_harshness[0].code - x->v.ansi_harshness[0].code;
  90.  
  91.   if (y->h.code & STD_CODE)
  92.     {
  93.       if (x->h.code & STD_CODE)
  94.     return y->h.distance - x->h.distance;
  95.       return 1;
  96.     }
  97.   if (x->h.code & STD_CODE)
  98.     return -1;
  99.  
  100.   return y->h.code - x->h.code;
  101. }
  102.  
  103. int
  104. rank_for_overload_old (x, y)
  105.      struct candidate *x, *y;
  106. {
  107.   if (y->evil - x->evil)
  108.     return y->evil - x->evil;
  109.   if (CONST_HARSHNESS (y->v.old_harshness[0]) ^ CONST_HARSHNESS (x->v.old_harshness[0]))
  110.     return y->v.old_harshness[0] - x->v.old_harshness[0];
  111.   if (y->ellipsis - x->ellipsis)
  112.     return y->ellipsis - x->ellipsis;
  113.   if (y->user - x->user)
  114.     return y->user - x->user;
  115.   if (y->b_or_d - x->b_or_d)
  116.     return y->b_or_d - x->b_or_d;
  117.   return y->easy - x->easy;
  118. }
  119.  
  120. int
  121. rank_for_overload (x, y)
  122.      struct candidate *x, *y;
  123. {
  124.   if (flag_ansi_overloading)
  125.     return rank_for_overload_ansi (x, y);
  126.   else
  127.     return rank_for_overload_old (x, y);
  128. }
  129.  
  130. /* Compare two candidates, argument by argument.  */
  131. int
  132. rank_for_ideal (x, y)
  133.      struct candidate *x, *y;
  134. {
  135.   int i;
  136.  
  137.   if (x->h_len != y->h_len)
  138.     abort ();
  139.  
  140.   for (i = 0; i < x->h_len; i++)
  141.     {
  142.       if (y->v.ansi_harshness[i].code - x->v.ansi_harshness[i].code)
  143.     return y->v.ansi_harshness[i].code - x->v.ansi_harshness[i].code;
  144.       if ((y->v.ansi_harshness[i].code & STD_CODE)
  145.       && (y->v.ansi_harshness[i].distance - x->v.ansi_harshness[i].distance))
  146.     return y->v.ansi_harshness[i].distance - x->v.ansi_harshness[i].distance;
  147.  
  148.       /* They're both the same code.  Now see if we're dealing with an
  149.      integral promotion that needs a finer grain of accuracy.  */
  150.       if (y->v.ansi_harshness[0].code & PROMO_CODE
  151.       && (y->v.ansi_harshness[i].int_penalty ^ x->v.ansi_harshness[i].int_penalty))
  152.     return y->v.ansi_harshness[i].int_penalty - x->v.ansi_harshness[i].int_penalty;
  153.     }
  154.   return 0;
  155. }
  156.  
  157. /* TYPE is the type we wish to convert to.  PARM is the parameter
  158.    we have to work with.  We use a somewhat arbitrary cost function
  159.    to measure this conversion.  */
  160. static struct harshness_code
  161. convert_harshness_ansi (type, parmtype, parm)
  162.      register tree type, parmtype;
  163.      tree parm;
  164. {
  165.   struct harshness_code h;
  166.   register enum tree_code codel;
  167.   register enum tree_code coder;
  168.  
  169.   h.code = 0;
  170.   h.distance = 0;
  171.   h.int_penalty = 0;
  172.  
  173. #ifdef GATHER_STATISTICS
  174.   n_convert_harshness++;
  175. #endif
  176.  
  177.   if (TYPE_PTRMEMFUNC_P (type))
  178.     type = TYPE_PTRMEMFUNC_FN_TYPE (type);
  179.   if (TYPE_PTRMEMFUNC_P (parmtype))
  180.     parmtype = TYPE_PTRMEMFUNC_FN_TYPE (parmtype);
  181.  
  182.   codel = TREE_CODE (type);
  183.   coder = TREE_CODE (parmtype);
  184.  
  185.   if (TYPE_MAIN_VARIANT (parmtype) == TYPE_MAIN_VARIANT (type))
  186.     return ZERO_RETURN (h);
  187.  
  188.   if (coder == ERROR_MARK)
  189.     return EVIL_RETURN (h);
  190.  
  191.   if (codel == POINTER_TYPE
  192.       && (coder == METHOD_TYPE || coder == FUNCTION_TYPE))
  193.     {
  194.       tree p1, p2;
  195.       struct harshness_code h1, h2;
  196.  
  197.       /* Get to the METHOD_TYPE or FUNCTION_TYPE that this might be.  */
  198.       type = TREE_TYPE (type);
  199.  
  200.       if (coder != TREE_CODE (type))
  201.     return EVIL_RETURN (h);
  202.  
  203.       /* We allow the default conversion between function type
  204.      and pointer-to-function type for free.  */
  205.       if (type == parmtype)
  206.     return ZERO_RETURN (h);
  207.  
  208.       /* Compare return types.  */
  209.       p1 = TREE_TYPE (type);
  210.       p2 = TREE_TYPE (parmtype);
  211.       h2 = convert_harshness_ansi (p1, p2, NULL_TREE);
  212.       if (h2.code & EVIL_CODE)
  213.     return h2;
  214.  
  215.       h1.code = TRIVIAL_CODE;
  216.       h1.distance = 0;
  217.  
  218.       if (h2.distance != 0)
  219.     {
  220.       tree binfo;
  221.  
  222.       /* This only works for pointers.  */
  223.       if (TREE_CODE (p1) != POINTER_TYPE
  224.           && TREE_CODE (p1) != REFERENCE_TYPE)
  225.         return EVIL_RETURN (h);
  226.  
  227.       p1 = TREE_TYPE (p1);
  228.       p2 = TREE_TYPE (p2);
  229.       /* Don't die if we happen to be dealing with void*.  */
  230.       if (!IS_AGGR_TYPE (p1) || !IS_AGGR_TYPE (p2))
  231.         return EVIL_RETURN (h);
  232.       if (h2.distance < 0)
  233.         binfo = get_binfo (p2, p1, 0);
  234.       else
  235.         binfo = get_binfo (p1, p2, 0);
  236.  
  237.       if (! BINFO_OFFSET_ZEROP (binfo))
  238.         {
  239.           static int explained = 0;
  240.           if (h2.distance < 0)
  241.         message_2_types (sorry, "cannot cast `%d' to `%d' at function call site", p2, p1);
  242.           else
  243.         message_2_types (sorry, "cannot cast `%d' to `%d' at function call site", p1, p2);
  244.  
  245.           if (! explained++)
  246.         sorry ("(because pointer values change during conversion)");
  247.           return EVIL_RETURN (h);
  248.         }
  249.     }
  250.  
  251.       h1.code |= h2.code;
  252.       if (h2.distance > h1.distance)
  253.     h1.distance = h2.distance;
  254.  
  255.       p1 = TYPE_ARG_TYPES (type);
  256.       p2 = TYPE_ARG_TYPES (parmtype);
  257.       while (p1 && TREE_VALUE (p1) != void_type_node
  258.          && p2 && TREE_VALUE (p2) != void_type_node)
  259.     {
  260.       h2 = convert_harshness_ansi (TREE_VALUE (p1), TREE_VALUE (p2),
  261.                        NULL_TREE);
  262.       if (h2.code & EVIL_CODE)
  263.         return h2;
  264.  
  265.       if (h2.distance)
  266.         {
  267.           /* This only works for pointers and references. */
  268.           if (TREE_CODE (TREE_VALUE (p1)) != POINTER_TYPE
  269.           && TREE_CODE (TREE_VALUE (p1)) != REFERENCE_TYPE)
  270.         return EVIL_RETURN (h);
  271.           h2.distance = - h2.distance;
  272.         }
  273.  
  274.       h1.code |= h2.code;
  275.       if (h2.distance > h1.distance)
  276.         h1.distance = h2.distance;
  277.       p1 = TREE_CHAIN (p1);
  278.       p2 = TREE_CHAIN (p2);
  279.     }
  280.       if (p1 == p2)
  281.     return h1;
  282.       if (p2)
  283.     {
  284.       if (p1)
  285.         return EVIL_RETURN (h);
  286.       h1.code |= ELLIPSIS_CODE;
  287.       return h1;
  288.     }
  289.       if (p1)
  290.     {
  291.       if (TREE_PURPOSE (p1) == NULL_TREE)
  292.         h1.code |= EVIL_CODE;
  293.       return h1;
  294.     }
  295.     }
  296.   else if (codel == POINTER_TYPE && coder == OFFSET_TYPE)
  297.     {
  298.       /* Get to the OFFSET_TYPE that this might be.  */
  299.       type = TREE_TYPE (type);
  300.  
  301.       if (coder != TREE_CODE (type))
  302.     return EVIL_RETURN (h);
  303.  
  304.       if (TYPE_OFFSET_BASETYPE (type) == TYPE_OFFSET_BASETYPE (parmtype))
  305.     h.code = 0;
  306.       else if (UNIQUELY_DERIVED_FROM_P (TYPE_OFFSET_BASETYPE (type),
  307.                    TYPE_OFFSET_BASETYPE (parmtype)))
  308.     {
  309.       h.code = STD_CODE;
  310.       h.distance = 1;
  311.     }
  312.       else if (UNIQUELY_DERIVED_FROM_P (TYPE_OFFSET_BASETYPE (parmtype),
  313.                    TYPE_OFFSET_BASETYPE (type)))
  314.     {
  315.       h.code = STD_CODE;
  316.       h.distance = -1;
  317.     }
  318.       else
  319.     return EVIL_RETURN (h);
  320.       /* Now test the OFFSET_TYPE's target compatibility.  */
  321.       type = TREE_TYPE (type);
  322.       parmtype = TREE_TYPE (parmtype);
  323.     }
  324.  
  325.   if (coder == UNKNOWN_TYPE)
  326.     {
  327.       if (codel == FUNCTION_TYPE
  328.       || codel == METHOD_TYPE
  329.       || (codel == POINTER_TYPE
  330.           && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
  331.           || TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)))
  332.     return TRIVIAL_RETURN (h);
  333.       return EVIL_RETURN (h);
  334.     }
  335.  
  336.   if (coder == VOID_TYPE)
  337.     return EVIL_RETURN (h);
  338.  
  339.   if (codel == ENUMERAL_TYPE || codel == INTEGER_TYPE)
  340.     {
  341.       /* Control equivalence of ints an enums.  */
  342.  
  343.       if (codel == ENUMERAL_TYPE
  344.       && flag_int_enum_equivalence == 0)
  345.     {
  346.       /* Enums can be converted to ints, but not vice-versa.  */
  347.       if (coder != ENUMERAL_TYPE
  348.           || TYPE_MAIN_VARIANT (type) != TYPE_MAIN_VARIANT (parmtype))
  349.         return EVIL_RETURN (h);
  350.     }
  351.  
  352.       /* else enums and ints (almost) freely interconvert.  */
  353.  
  354.       if (coder == INTEGER_TYPE || coder == ENUMERAL_TYPE)
  355.     {
  356.       if ((TREE_UNSIGNED (type) ^ TREE_UNSIGNED (parmtype))
  357.           || codel != coder
  358.           || TYPE_MODE (type) != TYPE_MODE (parmtype))
  359.         {
  360.           /* Make sure a value-preserving condition [from a smaller type to
  361.          a larger type] is preferred to a possibly value-destroying
  362.          standard conversion [from a larger type to a smaller type].  */
  363.           if (TYPE_PRECISION (type) >= TYPE_PRECISION (parmtype))
  364.         {
  365.           h.code = PROMO_CODE;
  366.           /* A char, short, wchar_t, etc., should promote to an int if
  367.              it can handle it, otherwise to an unsigned.  So we'll make
  368.              an unsigned.  */
  369.           if (type != integer_type_node)
  370.             h.int_penalty = 1;
  371.         }
  372.           else
  373.         h.code = STD_CODE;
  374.         }
  375.  
  376.       /* If the three above conditions didn't trigger, we have found two
  377.          very similar types.  On systems where they're the same size, we
  378.          can end up here with TYPE as `long' and PARMTYPE as `int'.  Make
  379.          sure we realize that, even though they're the same mode, we will
  380.          have to do some sort of integral promotion on the type, since
  381.          they're not the same.  */
  382.       if (! comptypes (type, parmtype, 1) && h.code == 0)
  383.         {
  384.           /* This call to common_type will return the best type for the
  385.          combination.  If it matches TYPE, that means we'll be converting
  386.          from a so-called smaller type (in PARMTYPE) to the larger in TYPE,
  387.          thus an integral promotion.  Otherwise, it must be going from a
  388.          larger type in PARMTYPE to a smaller expected type in TYPE, so we
  389.          make it a standard conversion instead.  */
  390.           if (common_type (type, parmtype) == type)
  391.         h.code = PROMO_CODE;
  392.           else
  393.         h.code = STD_CODE;
  394.         }
  395.         
  396.       return h;
  397.     }
  398.       else if (coder == REAL_TYPE)
  399.     {
  400.       h.code = STD_CODE;
  401.       h.distance = 0;
  402.       return h;
  403.     }
  404.     }
  405.  
  406.   if (codel == REAL_TYPE)
  407.     {
  408.       if (coder == REAL_TYPE)
  409.     {
  410.       /* Shun converting between float and double if a choice exists.  */
  411.       if (TYPE_MODE (type) != TYPE_MODE (parmtype))
  412.         {
  413.           h.code = PROMO_CODE;
  414.           return h;
  415.         }
  416.       return ZERO_RETURN (h);
  417.     }
  418.       else if (coder == INTEGER_TYPE || coder == ENUMERAL_TYPE)
  419.     {
  420.       h.code = STD_CODE;
  421.       h.distance = 0;
  422.       return h;
  423.     }
  424.     }
  425.  
  426.   /* Convert arrays which have not previously been converted.  */
  427.   if (codel == ARRAY_TYPE)
  428.     codel = POINTER_TYPE;
  429.   if (coder == ARRAY_TYPE)
  430.     coder = POINTER_TYPE;
  431.  
  432.   /* Conversions among pointers */
  433.   if (codel == POINTER_TYPE && coder == POINTER_TYPE)
  434.     {
  435.       register tree ttl = TYPE_MAIN_VARIANT (TREE_TYPE (type));
  436.       register tree ttr = TYPE_MAIN_VARIANT (TREE_TYPE (parmtype));
  437.       int penalty = 4 * (ttl != ttr);
  438.  
  439.       /* Anything converts to void *.  void * converts to anything.
  440.      Since these may be `const void *' (etc.) use VOID_TYPE
  441.      instead of void_type_node.  Otherwise, the targets must be the same,
  442.      except that we do allow (at some cost) conversion between signed and
  443.      unsinged pointer types.  */
  444.  
  445.       if ((TREE_CODE (ttl) == METHOD_TYPE
  446.        || TREE_CODE (ttl) == FUNCTION_TYPE)
  447.       && TREE_CODE (ttl) == TREE_CODE (ttr))
  448.     {
  449.       if (comptypes (ttl, ttr, -1))
  450.         {
  451.           h.code = penalty ? STD_CODE : 0;
  452.           h.distance =  0;
  453.         }
  454.       else
  455.         h.code = EVIL_CODE;
  456.       return h;
  457.     }
  458.  
  459. #if 1
  460.       if (TREE_CODE (ttl) != VOID_TYPE && TREE_CODE (ttr) != VOID_TYPE)
  461.     {
  462.       if (TREE_UNSIGNED (ttl) != TREE_UNSIGNED (ttr))
  463.         {
  464.           ttl = unsigned_type (ttl);
  465.           ttr = unsigned_type (ttr);
  466.           penalty = 10;
  467.         }
  468.       if (! comp_target_types (ttl, ttr, 0))
  469.         return EVIL_RETURN (h);
  470.     }
  471. #else
  472.       if (!(TREE_CODE (ttl) == VOID_TYPE
  473.         || TREE_CODE (ttr) == VOID_TYPE
  474.         || (TREE_UNSIGNED (ttl) ^ TREE_UNSIGNED (ttr)
  475.         && (ttl = unsigned_type (ttl),
  476.             ttr = unsigned_type (ttr),
  477.             penalty = 10, 0))
  478.         || (comp_target_types (ttl, ttr, 0))))
  479.     return EVIL_RETURN (h);
  480. #endif
  481.  
  482.       if (penalty == 10 || ttr == ttl)
  483.     {
  484.       tree tmp1 = TREE_TYPE (type), tmp2 = TREE_TYPE (parmtype);
  485.  
  486.       /* If one was unsigned but the other wasn't, then we need to
  487.          do a standard conversion from T to unsigned T.  */
  488.       if (penalty == 10)
  489.         h.code = PROMO_CODE; /* was STD_CODE */
  490.       else
  491.         h.code = 0;
  492.  
  493.       /* Note conversion from `T*' to `const T*',
  494.                            or `T*' to `volatile T*'.  */
  495.       if (ttl == ttr
  496.           && ((TYPE_READONLY (tmp1) != TREE_READONLY (tmp2))
  497.           || (TYPE_VOLATILE (tmp1) != TYPE_VOLATILE (tmp2))))
  498.         h.code |= QUAL_CODE;
  499.  
  500.       h.distance = 0;
  501.       return h;
  502.     }
  503.  
  504.  
  505.       if (TREE_CODE (ttl) == RECORD_TYPE && TREE_CODE (ttr) == RECORD_TYPE)
  506.     {
  507.       int b_or_d = get_base_distance (ttl, ttr, 0, 0);
  508.       if (b_or_d < 0)
  509.         {
  510.           b_or_d = get_base_distance (ttr, ttl, 0, 0);
  511.           if (b_or_d < 0)
  512.         return EVIL_RETURN (h);
  513.           h.distance = -b_or_d;
  514.         }
  515.       else
  516.         h.distance = b_or_d;
  517.       h.code = STD_CODE;
  518.       return h;
  519.     }
  520.  
  521.       /* If converting from a `class*' to a `void*', make it
  522.      less favorable than any inheritance relationship.  */
  523.       if (TREE_CODE (ttl) == VOID_TYPE && IS_AGGR_TYPE (ttr))
  524.     {
  525.       h.code = STD_CODE;
  526.       h.distance = CLASSTYPE_MAX_DEPTH (ttr)+1;
  527.       return h;
  528.     }
  529.       h.code = penalty ? STD_CODE : PROMO_CODE;
  530.       return h;
  531.     }
  532.  
  533.   if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
  534.     {
  535.       /* This is not a bad match, but don't let it beat
  536.      integer-enum combinations.  */
  537.       if (parm && integer_zerop (parm))
  538.     {
  539.       h.code = STD_CODE;
  540.       h.distance = 0;
  541.       return h;
  542.     }
  543.     }
  544.  
  545.   /* C++: one of the types must be a reference type.  */
  546.   {
  547.     tree ttl, ttr;
  548.     register tree intype = TYPE_MAIN_VARIANT (parmtype);
  549.     register enum tree_code form = TREE_CODE (intype);
  550.     int penalty;
  551.  
  552.     if (codel == REFERENCE_TYPE || coder == REFERENCE_TYPE)
  553.       {
  554.     ttl = TYPE_MAIN_VARIANT (type);
  555.  
  556.     if (codel == REFERENCE_TYPE)
  557.       {
  558.         ttl = TREE_TYPE (ttl);
  559.  
  560.         /* When passing a non-const argument into a const reference,
  561.            dig it a little, so a non-const reference is preferred over
  562.            this one. (mrs) */
  563.         if (parm && TREE_READONLY (ttl) && ! TREE_READONLY (parm))
  564.           penalty = 2;
  565.         else
  566.           penalty = 0;
  567.  
  568.         ttl = TYPE_MAIN_VARIANT (ttl);
  569.  
  570.         if (form == OFFSET_TYPE)
  571.           {
  572.         intype = TREE_TYPE (intype);
  573.         form = TREE_CODE (intype);
  574.           }
  575.  
  576.         if (form == REFERENCE_TYPE)
  577.           {
  578.         intype = TYPE_MAIN_VARIANT (TREE_TYPE (intype));
  579.  
  580.         if (ttl == intype)
  581.           return ZERO_RETURN (h);
  582.         penalty = 2;
  583.           }
  584.         else
  585.           {
  586.         /* Can reference be built up?  */
  587.         if (ttl == intype && penalty == 0) {
  588.           /* Because the READONLY and VIRTUAL bits are not always in
  589.              the type, this extra check is necessary.  The problem
  590.              should be fixed someplace else, and this extra code
  591.              removed.
  592.  
  593.              Also, if type if a reference, the readonly bits could
  594.              either be in the outer type (with reference) or on the
  595.              inner type (the thing being referenced).  (mrs)  */
  596.           if (parm
  597.               && ((TREE_READONLY (parm)
  598.                && ! (TYPE_READONLY (type)
  599.                  || (TREE_CODE (type) == REFERENCE_TYPE
  600.                      && TYPE_READONLY (TREE_TYPE (type)))))
  601.               || (TREE_SIDE_EFFECTS (parm)
  602.                   && ! (TYPE_VOLATILE (type)
  603.                     || (TREE_CODE (type) == REFERENCE_TYPE
  604.                     && TYPE_VOLATILE (TREE_TYPE (type)))))))
  605.             penalty = 2;
  606.           else
  607.             return ZERO_RETURN (h);
  608.         }
  609.         else
  610.           penalty = 2;
  611.           }
  612.       }
  613.     else if (form == REFERENCE_TYPE)
  614.       {
  615.         if (parm)
  616.           {
  617.         tree tmp = convert_from_reference (parm);
  618.         intype = TYPE_MAIN_VARIANT (TREE_TYPE (tmp));
  619.           }
  620.         else
  621.           {
  622.         intype = parmtype;
  623.         do
  624.           intype = TREE_TYPE (intype);
  625.         while (TREE_CODE (intype) == REFERENCE_TYPE);
  626.         intype = TYPE_MAIN_VARIANT (intype);
  627.           }
  628.  
  629.         if (ttl == intype)
  630.           return ZERO_RETURN (h);
  631.         else
  632.           penalty = 2;
  633.       }
  634.  
  635.     if (TREE_UNSIGNED (ttl) ^ TREE_UNSIGNED (intype))
  636.       {
  637.         ttl = unsigned_type (ttl);
  638.         intype = unsigned_type (intype);
  639.         penalty += 2;
  640.       }
  641.  
  642.     ttr = intype;
  643.  
  644.     /* If the initializer is not an lvalue, then it does not
  645.        matter if we make life easier for the programmer
  646.        by creating a temporary variable with which to
  647.        hold the result.  */
  648.     if (parm && (coder == INTEGER_TYPE
  649.              || coder == ENUMERAL_TYPE
  650.              || coder == REAL_TYPE)
  651.         && ! lvalue_p (parm))
  652.       {
  653.         h = convert_harshness_ansi (ttl, ttr, NULL_TREE);
  654.         if (penalty)
  655.           h.code |= STD_CODE;
  656.         h.distance = 0;
  657.         return h;
  658.       }
  659.  
  660.     if (ttl == ttr)
  661.       {
  662.         if (penalty > 2)
  663.           {
  664.         h.code = STD_CODE;
  665.         h.distance = 0;
  666.           }
  667.         else
  668.           {
  669.         h.code = TRIVIAL_CODE;
  670.         /* We set this here so that build_overload_call_real will be
  671.            able to see the penalty we found, rather than just looking
  672.            at a TRIVIAL_CODE with no other information.  */
  673.         h.int_penalty = penalty;
  674.           }
  675.         return h;
  676.       }
  677.  
  678.     /* Pointers to voids always convert for pointers.  But
  679.        make them less natural than more specific matches.  */
  680.     if (TREE_CODE (ttl) == POINTER_TYPE && TREE_CODE (ttr) == POINTER_TYPE)
  681.       {
  682.         if (TREE_TYPE (ttl) == void_type_node
  683.         || TREE_TYPE (ttr) == void_type_node)
  684.           {
  685.         h.code = STD_CODE;
  686.         h.distance = 0;
  687.         return h;
  688.           }
  689.       }
  690.  
  691.     if (parm && codel != REFERENCE_TYPE)
  692.       {
  693.         h = convert_harshness_ansi (ttl, ttr, NULL_TREE);
  694.         if (penalty)
  695.           h.code |= STD_CODE;
  696.         h.distance = 0;
  697.         return h;
  698.       }
  699.  
  700.     /* Here it does matter.  If this conversion is from derived to base,
  701.        allow it.  Otherwise, types must be compatible in the strong sense.  */
  702.     if (TREE_CODE (ttl) == RECORD_TYPE && TREE_CODE (ttr) == RECORD_TYPE)
  703.       {
  704.         int b_or_d = get_base_distance (ttl, ttr, 0, 0);
  705.         if (b_or_d < 0)
  706.           {
  707.         b_or_d = get_base_distance (ttr, ttl, 0, 0);
  708.         if (b_or_d < 0)
  709.           return EVIL_RETURN (h);
  710.         h.distance = -b_or_d;
  711.           }
  712.         /* Say that this conversion is relatively painless.
  713.            If it turns out that there is a user-defined X(X&)
  714.            constructor, then that will be invoked, but that's
  715.            preferable to dealing with other user-defined conversions
  716.            that may produce surprising results.  */
  717.         else
  718.           h.distance = b_or_d;
  719.         h.code = STD_CODE;
  720.         return h;
  721.       }
  722.  
  723.     if (comp_target_types (ttl, intype, 1))
  724.       {
  725.         if (penalty)
  726.           h.code = STD_CODE;
  727.         h.distance = 0;
  728.         return h;
  729.       }
  730.       }
  731.   }
  732.   if (codel == RECORD_TYPE && coder == RECORD_TYPE)
  733.     {
  734.       int b_or_d = get_base_distance (type, parmtype, 0, 0);
  735.       if (b_or_d < 0)
  736.     {
  737.       b_or_d = get_base_distance (parmtype, type, 0, 0);
  738.       if (b_or_d < 0)
  739.         return EVIL_RETURN (h);
  740.       h.distance = -b_or_d;
  741.     }
  742.       else
  743.     h.distance = b_or_d;
  744.       h.code = STD_CODE;
  745.       return h;
  746.     }
  747.   return EVIL_RETURN (h);
  748. }
  749.  
  750. /* TYPE is the type we wish to convert to.  PARM is the parameter
  751.    we have to work with.  We use a somewhat arbitrary cost function
  752.    to measure this conversion.  */
  753. static int
  754. convert_harshness_old (type, parmtype, parm)
  755.      register tree type, parmtype;
  756.      tree parm;
  757. {
  758.   register enum tree_code codel;
  759.   register enum tree_code coder;
  760.  
  761. #ifdef GATHER_STATISTICS
  762.   n_convert_harshness++;
  763. #endif
  764.  
  765.   if (TYPE_PTRMEMFUNC_P (type))
  766.     type = TYPE_PTRMEMFUNC_FN_TYPE (type);
  767.   if (TYPE_PTRMEMFUNC_P (parmtype))
  768.     parmtype = TYPE_PTRMEMFUNC_FN_TYPE (parmtype);
  769.  
  770.   codel = TREE_CODE (type);
  771.   coder = TREE_CODE (parmtype);
  772.  
  773.   if (TYPE_MAIN_VARIANT (parmtype) == TYPE_MAIN_VARIANT (type))
  774.     return TRIVIAL;
  775.  
  776.   if (coder == ERROR_MARK)
  777.     return EVIL;
  778.  
  779.   if (codel == POINTER_TYPE
  780.       && (coder == METHOD_TYPE || coder == FUNCTION_TYPE))
  781.     {
  782.       tree p1, p2;
  783.       int harshness, new_harshness;
  784.  
  785.       /* Get to the METHOD_TYPE or FUNCTION_TYPE that this might be.  */
  786.       type = TREE_TYPE (type);
  787.  
  788.       if (coder != TREE_CODE (type))
  789.     return EVIL;
  790.  
  791.       harshness = 0;
  792.  
  793.       /* We allow the default conversion between function type
  794.      and pointer-to-function type for free.  */
  795.       if (type == parmtype)
  796.     return TRIVIAL;
  797.  
  798.       /* Compare return types.  */
  799.       p1 = TREE_TYPE (type);
  800.       p2 = TREE_TYPE (parmtype);
  801.       new_harshness = convert_harshness_old (p1, p2, NULL_TREE);
  802.       if (EVIL_HARSHNESS (new_harshness))
  803.     return EVIL;
  804.  
  805.       if (BASE_DERIVED_HARSHNESS (new_harshness))
  806.     {
  807.       tree binfo;
  808.  
  809.       /* This only works for pointers.  */
  810.       if (TREE_CODE (p1) != POINTER_TYPE
  811.           && TREE_CODE (p1) != REFERENCE_TYPE)
  812.         return EVIL;
  813.  
  814.       p1 = TREE_TYPE (p1);
  815.       p2 = TREE_TYPE (p2);
  816.       /* Don't die if we happen to be dealing with void*.  */
  817.       if (!IS_AGGR_TYPE (p1) || !IS_AGGR_TYPE (p2))
  818.         return EVIL;
  819.       if (CONTRAVARIANT_HARSHNESS (new_harshness))
  820.         binfo = get_binfo (p2, p1, 0);
  821.       else
  822.         binfo = get_binfo (p1, p2, 0);
  823.  
  824.       if (! BINFO_OFFSET_ZEROP (binfo))
  825.         {
  826.           static int explained = 0;
  827.           if (CONTRAVARIANT_HARSHNESS (new_harshness))
  828.         message_2_types (sorry, "cannot cast `%d' to `%d' at function call site", p2, p1);
  829.           else
  830.         message_2_types (sorry, "cannot cast `%d' to `%d' at function call site", p1, p2);
  831.  
  832.           if (! explained++)
  833.         sorry ("(because pointer values change during conversion)");
  834.           return EVIL;
  835.         }
  836.     }
  837.  
  838.       harshness |= new_harshness;
  839.  
  840.       p1 = TYPE_ARG_TYPES (type);
  841.       p2 = TYPE_ARG_TYPES (parmtype);
  842.       while (p1 && TREE_VALUE (p1) != void_type_node
  843.          && p2 && TREE_VALUE (p2) != void_type_node)
  844.     {
  845.       new_harshness = convert_harshness_old (TREE_VALUE (p1),
  846.                          TREE_VALUE (p2), NULL_TREE);
  847.       if (EVIL_HARSHNESS (new_harshness))
  848.         return EVIL;
  849.  
  850.       if (BASE_DERIVED_HARSHNESS (new_harshness))
  851.         {
  852.           /* This only works for pointers and references. */
  853.           if (TREE_CODE (TREE_VALUE (p1)) != POINTER_TYPE
  854.           && TREE_CODE (TREE_VALUE (p1)) != REFERENCE_TYPE)
  855.         return EVIL;
  856.           new_harshness ^= CONTRAVARIANT_HARSHNESS (new_harshness);
  857.           harshness |= new_harshness;
  858.         }
  859.       /* This trick allows use to accumulate easy type
  860.          conversions without messing up the bits that encode
  861.          info about more involved things.  */
  862.       else if (ONLY_EASY_HARSHNESS (new_harshness))
  863.         harshness += new_harshness;
  864.       else
  865.         harshness |= new_harshness;
  866.       p1 = TREE_CHAIN (p1);
  867.       p2 = TREE_CHAIN (p2);
  868.     }
  869.       if (p1 == p2)
  870.     return harshness;
  871.       if (p2)
  872.     return p1 ? EVIL : (harshness | ELLIPSIS_HARSHNESS (-1));
  873.       if (p1)
  874.     return harshness | (TREE_PURPOSE (p1) == NULL_TREE);
  875.     }
  876.   else if (codel == POINTER_TYPE && coder == OFFSET_TYPE)
  877.     {
  878.       /* XXX: Note this is set a few times, but it's never actually
  879.      used! (bpk) */
  880.       int harshness;
  881.  
  882.       /* Get to the OFFSET_TYPE that this might be.  */
  883.       type = TREE_TYPE (type);
  884.  
  885.       if (coder != TREE_CODE (type))
  886.     return EVIL;
  887.  
  888.       harshness = 0;
  889.  
  890.       if (TYPE_OFFSET_BASETYPE (type) == TYPE_OFFSET_BASETYPE (parmtype))
  891.     harshness = 0;
  892.       else if (UNIQUELY_DERIVED_FROM_P (TYPE_OFFSET_BASETYPE (type),
  893.                    TYPE_OFFSET_BASETYPE (parmtype)))
  894.     harshness = INT_TO_BD_HARSHNESS (1);
  895.       else if (UNIQUELY_DERIVED_FROM_P (TYPE_OFFSET_BASETYPE (parmtype),
  896.                    TYPE_OFFSET_BASETYPE (type)))
  897.     harshness = CONTRAVARIANT_HARSHNESS (-1);
  898.       else
  899.     return EVIL;
  900.       /* Now test the OFFSET_TYPE's target compatibility.  */
  901.       type = TREE_TYPE (type);
  902.       parmtype = TREE_TYPE (parmtype);
  903.     }
  904.  
  905.   if (coder == UNKNOWN_TYPE)
  906.     {
  907.       if (codel == FUNCTION_TYPE
  908.       || codel == METHOD_TYPE
  909.       || (codel == POINTER_TYPE
  910.           && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
  911.           || TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)))
  912.     return TRIVIAL;
  913.       return EVIL;
  914.     }
  915.  
  916.   if (coder == VOID_TYPE)
  917.     return EVIL;
  918.  
  919.   if (codel == ENUMERAL_TYPE || codel == INTEGER_TYPE)
  920.     {
  921.       /* Control equivalence of ints an enums.  */
  922.  
  923.       if (codel == ENUMERAL_TYPE
  924.       && flag_int_enum_equivalence == 0)
  925.     {
  926.       /* Enums can be converted to ints, but not vice-versa.  */
  927.       if (coder != ENUMERAL_TYPE
  928.           || TYPE_MAIN_VARIANT (type) != TYPE_MAIN_VARIANT (parmtype))
  929.         return EVIL;
  930.     }
  931.  
  932.       /* else enums and ints (almost) freely interconvert.  */
  933.  
  934.       if (coder == INTEGER_TYPE || coder == ENUMERAL_TYPE)
  935.     {
  936.       int easy = TREE_UNSIGNED (type) ^ TREE_UNSIGNED (parmtype);
  937.       if (codel != coder)
  938.         easy += 1;
  939.       if (TYPE_MODE (type) != TYPE_MODE (parmtype))
  940.         easy += 2;
  941.       return INT_TO_EASY_HARSHNESS (easy);
  942.     }
  943.       else if (coder == REAL_TYPE)
  944.     return INT_TO_EASY_HARSHNESS (4);
  945.     }
  946.  
  947.   if (codel == REAL_TYPE)
  948.     if (coder == REAL_TYPE)
  949.       /* Shun converting between float and double if a choice exists.  */
  950.       {
  951.     if (TYPE_MODE (type) != TYPE_MODE (parmtype))
  952.       return INT_TO_EASY_HARSHNESS (2);
  953.     return TRIVIAL;
  954.       }
  955.     else if (coder == INTEGER_TYPE || coder == ENUMERAL_TYPE)
  956.       return INT_TO_EASY_HARSHNESS (4);
  957.  
  958.   /* convert arrays which have not previously been converted.  */
  959.   if (codel == ARRAY_TYPE)
  960.     codel = POINTER_TYPE;
  961.   if (coder == ARRAY_TYPE)
  962.     coder = POINTER_TYPE;
  963.  
  964.   /* Conversions among pointers */
  965.   if (codel == POINTER_TYPE && coder == POINTER_TYPE)
  966.     {
  967.       register tree ttl = TYPE_MAIN_VARIANT (TREE_TYPE (type));
  968.       register tree ttr = TYPE_MAIN_VARIANT (TREE_TYPE (parmtype));
  969.       int penalty = 4 * (ttl != ttr);
  970.       /* Anything converts to void *.  void * converts to anything.
  971.      Since these may be `const void *' (etc.) use VOID_TYPE
  972.      instead of void_type_node.
  973.      Otherwise, the targets must be the same,
  974.      except that we do allow (at some cost) conversion
  975.      between signed and unsinged pointer types.  */
  976.  
  977.       if ((TREE_CODE (ttl) == METHOD_TYPE
  978.        || TREE_CODE (ttl) == FUNCTION_TYPE)
  979.       && TREE_CODE (ttl) == TREE_CODE (ttr))
  980.     {
  981.       if (comptypes (ttl, ttr, -1))
  982.         return INT_TO_EASY_HARSHNESS (penalty);
  983.       return EVIL;
  984.     }
  985.  
  986.       if (!(TREE_CODE (ttl) == VOID_TYPE
  987.         || TREE_CODE (ttr) == VOID_TYPE
  988.         || (TREE_UNSIGNED (ttl) ^ TREE_UNSIGNED (ttr)
  989.         && (ttl = unsigned_type (ttl),
  990.             ttr = unsigned_type (ttr),
  991.             penalty = 10, 0))
  992.         || (comp_target_types (ttl, ttr, 0))))
  993.     return EVIL;
  994.  
  995.       if (penalty == 10)
  996.     return INT_TO_EASY_HARSHNESS (10);
  997.       if (ttr == ttl)
  998.     return INT_TO_BD_HARSHNESS (0);
  999.  
  1000.       if (TREE_CODE (ttl) == RECORD_TYPE && TREE_CODE (ttr) == RECORD_TYPE)
  1001.     {
  1002.       int b_or_d = get_base_distance (ttl, ttr, 0, 0);
  1003.       if (b_or_d < 0)
  1004.         {
  1005.           b_or_d = get_base_distance (ttr, ttl, 0, 0);
  1006.           if (b_or_d < 0)
  1007.         return EVIL;
  1008.           return CONTRAVARIANT_HARSHNESS (-1);
  1009.         }
  1010.       return INT_TO_BD_HARSHNESS (b_or_d);
  1011.     }
  1012.       /* If converting from a `class*' to a `void*', make it
  1013.      less favorable than any inheritance relationship.  */
  1014.       if (TREE_CODE (ttl) == VOID_TYPE && IS_AGGR_TYPE (ttr))
  1015.     return INT_TO_BD_HARSHNESS (CLASSTYPE_MAX_DEPTH (ttr)+1);
  1016.       return INT_TO_EASY_HARSHNESS (penalty);
  1017.     }
  1018.  
  1019.   if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
  1020.     {
  1021.       /* This is not a bad match, but don't let it beat
  1022.      integer-enum combinations.  */
  1023.       if (parm && integer_zerop (parm))
  1024.     return INT_TO_EASY_HARSHNESS (4);
  1025.     }
  1026.  
  1027.   /* C++: one of the types must be a reference type.  */
  1028.   {
  1029.     tree ttl, ttr;
  1030.     register tree intype = TYPE_MAIN_VARIANT (parmtype);
  1031.     register enum tree_code form = TREE_CODE (intype);
  1032.     int penalty;
  1033.  
  1034.     if (codel == REFERENCE_TYPE || coder == REFERENCE_TYPE)
  1035.       {
  1036.     ttl = TYPE_MAIN_VARIANT (type);
  1037.  
  1038.     if (codel == REFERENCE_TYPE)
  1039.       {
  1040.         ttl = TREE_TYPE (ttl);
  1041.  
  1042.         /* When passing a non-const argument into a const reference,
  1043.            dig it a little, so a non-const reference is preferred over
  1044.            this one. (mrs) */
  1045.         if (parm && TREE_READONLY (ttl) && ! TREE_READONLY (parm))
  1046.           penalty = 2;
  1047.         else
  1048.           penalty = 0;
  1049.  
  1050.         ttl = TYPE_MAIN_VARIANT (ttl);
  1051.  
  1052.         if (form == OFFSET_TYPE)
  1053.           {
  1054.         intype = TREE_TYPE (intype);
  1055.         form = TREE_CODE (intype);
  1056.           }
  1057.  
  1058.         if (form == REFERENCE_TYPE)
  1059.           {
  1060.         intype = TYPE_MAIN_VARIANT (TREE_TYPE (intype));
  1061.  
  1062.         if (ttl == intype)
  1063.           return TRIVIAL;
  1064.         penalty = 2;
  1065.           }
  1066.         else
  1067.           {
  1068.         /* Can reference be built up?  */
  1069.         if (ttl == intype && penalty == 0) {
  1070.           /* Because the READONLY bits and VIRTUAL bits are not always
  1071.              in the type, this extra check is necessary.  The problem
  1072.              should be fixed someplace else, and this extra code
  1073.              removed.
  1074.  
  1075.              Also, if type if a reference, the readonly bits could
  1076.              either be in the outer type (with reference) or on the
  1077.              inner type (the thing being referenced).  (mrs)  */
  1078.           if (parm
  1079.               && ((TREE_READONLY (parm)
  1080.                && ! (TYPE_READONLY (type)
  1081.                  || (TREE_CODE (type) == REFERENCE_TYPE
  1082.                      && TYPE_READONLY (TREE_TYPE (type)))))
  1083.               || (TREE_SIDE_EFFECTS (parm)
  1084.                   && ! (TYPE_VOLATILE (type)
  1085.                     || (TREE_CODE (type) == REFERENCE_TYPE
  1086.                     && TYPE_VOLATILE (TREE_TYPE (type)))))))
  1087.             penalty = 2;
  1088.           else
  1089.             return TRIVIAL;
  1090.         }
  1091.         else
  1092.           penalty = 2;
  1093.           }
  1094.       }
  1095.     else if (form == REFERENCE_TYPE)
  1096.       {
  1097.         if (parm)
  1098.           {
  1099.         tree tmp = convert_from_reference (parm);
  1100.         intype = TYPE_MAIN_VARIANT (TREE_TYPE (tmp));
  1101.           }
  1102.         else
  1103.           {
  1104.         intype = parmtype;
  1105.         do
  1106.           {
  1107.             intype = TREE_TYPE (intype);
  1108.           }
  1109.         while (TREE_CODE (intype) == REFERENCE_TYPE);
  1110.         intype = TYPE_MAIN_VARIANT (intype);
  1111.           }
  1112.  
  1113.         if (ttl == intype)
  1114.           return TRIVIAL;
  1115.         else
  1116.           penalty = 2;
  1117.       }
  1118.  
  1119.     if (TREE_UNSIGNED (ttl) ^ TREE_UNSIGNED (intype))
  1120.       {
  1121.         ttl = unsigned_type (ttl);
  1122.         intype = unsigned_type (intype);
  1123.         penalty += 2;
  1124.       }
  1125.  
  1126.     ttr = intype;
  1127.  
  1128.     /* If the initializer is not an lvalue, then it does not
  1129.        matter if we make life easier for the programmer
  1130.        by creating a temporary variable with which to
  1131.        hold the result.  */
  1132.     if (parm && (coder == INTEGER_TYPE
  1133.              || coder == ENUMERAL_TYPE
  1134.              || coder == REAL_TYPE)
  1135.         && ! lvalue_p (parm))
  1136.       return (convert_harshness_old (ttl, ttr, NULL_TREE)
  1137.           | INT_TO_EASY_HARSHNESS (penalty));
  1138.  
  1139.     if (ttl == ttr)
  1140.       {
  1141.         if (penalty)
  1142.           return INT_TO_EASY_HARSHNESS (penalty);
  1143.         return INT_TO_BD_HARSHNESS (0);
  1144.       }
  1145.  
  1146.     /* Pointers to voids always convert for pointers.  But
  1147.        make them less natural than more specific matches.  */
  1148.     if (TREE_CODE (ttl) == POINTER_TYPE && TREE_CODE (ttr) == POINTER_TYPE)
  1149.       if (TREE_TYPE (ttl) == void_type_node
  1150.           || TREE_TYPE (ttr) == void_type_node)
  1151.         return INT_TO_EASY_HARSHNESS (penalty+1);
  1152.  
  1153.     if (parm && codel != REFERENCE_TYPE)
  1154.       return (convert_harshness_old (ttl, ttr, NULL_TREE)
  1155.           | INT_TO_EASY_HARSHNESS (penalty));
  1156.  
  1157.     /* Here it does matter.  If this conversion is from
  1158.        derived to base, allow it.  Otherwise, types must
  1159.        be compatible in the strong sense.  */
  1160.     if (TREE_CODE (ttl) == RECORD_TYPE && TREE_CODE (ttr) == RECORD_TYPE)
  1161.       {
  1162.         int b_or_d = get_base_distance (ttl, ttr, 0, 0);
  1163.         if (b_or_d < 0)
  1164.           {
  1165.         b_or_d = get_base_distance (ttr, ttl, 0, 0);
  1166.         if (b_or_d < 0)
  1167.           return EVIL;
  1168.         return CONTRAVARIANT_HARSHNESS (-1);
  1169.           }
  1170.         /* Say that this conversion is relatively painless.
  1171.            If it turns out that there is a user-defined X(X&)
  1172.            constructor, then that will be invoked, but that's
  1173.            preferable to dealing with other user-defined conversions
  1174.            that may produce surprising results.  */
  1175.         return INT_TO_BD_HARSHNESS (b_or_d);
  1176.       }
  1177.  
  1178.     if (comp_target_types (ttl, intype, 1))
  1179.       return INT_TO_EASY_HARSHNESS (penalty);
  1180.       }
  1181.   }
  1182.   if (codel == RECORD_TYPE && coder == RECORD_TYPE)
  1183.     {
  1184.       int b_or_d = get_base_distance (type, parmtype, 0, 0);
  1185.       if (b_or_d < 0)
  1186.     {
  1187.       b_or_d = get_base_distance (parmtype, type, 0, 0);
  1188.       if (b_or_d < 0)
  1189.         return EVIL;
  1190.       return CONTRAVARIANT_HARSHNESS (-1);
  1191.     }
  1192.       return INT_TO_BD_HARSHNESS (b_or_d);
  1193.     }
  1194.   return EVIL;
  1195. }
  1196.  
  1197. /* Algorithm: For each argument, calculate how difficult it is to
  1198.    make FUNCTION accept that argument.  If we can easily tell that
  1199.    FUNCTION won't be acceptable to one of the arguments, then we
  1200.    don't need to compute the ease of converting the other arguments,
  1201.    since it will never show up in the intersection of all arguments'
  1202.    favorite functions.
  1203.  
  1204.    Conversions between builtin and user-defined types are allowed, but
  1205.    no function involving such a conversion is preferred to one which
  1206.    does not require such a conversion.  Furthermore, such conversions
  1207.    must be unique.  */
  1208.  
  1209. void
  1210. compute_conversion_costs_ansi (function, tta_in, cp, arglen)
  1211.      tree function;
  1212.      tree tta_in;
  1213.      struct candidate *cp;
  1214.      int arglen;
  1215. {
  1216.   tree ttf_in = TYPE_ARG_TYPES (TREE_TYPE (function));
  1217.   tree ttf = ttf_in;
  1218.   tree tta = tta_in;
  1219.  
  1220.   /* Start out with no strikes against.  */
  1221.   int evil_strikes = 0;
  1222.   int ellipsis_strikes = 0;
  1223.   int user_strikes = 0;
  1224.   int b_or_d_strikes = 0;
  1225.   int easy_strikes = 0;
  1226.  
  1227.   int strike_index = 0, win;
  1228.   struct harshness_code lose;
  1229.  
  1230. #ifdef GATHER_STATISTICS
  1231.   n_compute_conversion_costs++;
  1232. #endif
  1233.  
  1234.   cp->function = function;
  1235.   cp->arg = tta ? TREE_VALUE (tta) : NULL_TREE;
  1236.   cp->u.bad_arg = 0;        /* optimistic!  */
  1237.  
  1238.   cp->h.code = 0;
  1239.   cp->h.distance = 0;
  1240.   cp->h.int_penalty = 0;
  1241.   bzero (cp->v.ansi_harshness, (arglen+1) * sizeof (short));
  1242.  
  1243.   while (ttf && tta)
  1244.     {
  1245.       struct harshness_code h;
  1246.  
  1247.       if (ttf == void_list_node)
  1248.     break;
  1249.  
  1250.       if (type_unknown_p (TREE_VALUE (tta)))
  1251.     {      
  1252.       /* Must perform some instantiation here.  */
  1253.       tree rhs = TREE_VALUE (tta);
  1254.       tree lhstype = TREE_VALUE (ttf);
  1255.  
  1256.       /* Keep quiet about possible contravariance violations.  */
  1257.       int old_inhibit_warnings = inhibit_warnings;
  1258.       inhibit_warnings = 1;
  1259.  
  1260.       /* @@ This is to undo what `grokdeclarator' does to
  1261.          parameter types.  It really should go through
  1262.          something more general.  */
  1263.  
  1264.       TREE_TYPE (tta) = unknown_type_node;
  1265.       rhs = instantiate_type (lhstype, rhs, 0);
  1266.       inhibit_warnings = old_inhibit_warnings;
  1267.  
  1268.       if (TREE_CODE (rhs) == ERROR_MARK)
  1269.         h.code = EVIL_CODE;
  1270.       else
  1271.         h = convert_harshness_ansi (lhstype, TREE_TYPE (rhs), rhs);
  1272.     }
  1273.       else
  1274.     h = convert_harshness_ansi (TREE_VALUE (ttf),
  1275.                     TREE_TYPE (TREE_VALUE (tta)),
  1276.                     TREE_VALUE (tta));
  1277.  
  1278.       cp->v.ansi_harshness[strike_index] = h;
  1279.       if ((h.code & EVIL_CODE)
  1280.       || ((h.code & STD_CODE) && h.distance < 0))
  1281.     {
  1282.       cp->u.bad_arg = strike_index;
  1283.       evil_strikes = 1;
  1284.     }
  1285.      else if (h.code & ELLIPSIS_CODE)
  1286.        ellipsis_strikes += 1;
  1287. #if 0
  1288.       /* This is never set by `convert_harshness_ansi'.  */
  1289.       else if (h.code & USER_CODE)
  1290.     {
  1291.       user_strikes += 1;
  1292.     }
  1293. #endif
  1294.       else
  1295.     {
  1296.       if ((h.code & STD_CODE) && h.distance)
  1297.         {
  1298.           if (h.distance > b_or_d_strikes)
  1299.         b_or_d_strikes = h.distance;
  1300.         }
  1301.       else
  1302.         easy_strikes += (h.code & (STD_CODE|PROMO_CODE|TRIVIAL_CODE));
  1303.       cp->h.code |= h.code;
  1304.       /* Make sure we communicate this.  */
  1305.       cp->h.int_penalty += h.int_penalty;
  1306.     }
  1307.  
  1308.       ttf = TREE_CHAIN (ttf);
  1309.       tta = TREE_CHAIN (tta);
  1310.       strike_index += 1;
  1311.     }
  1312.  
  1313.   if (tta)
  1314.     {
  1315.       /* ran out of formals, and parmlist is fixed size.  */
  1316.       if (ttf /* == void_type_node */)
  1317.     {
  1318.       cp->h.code = EVIL_CODE;
  1319.       cp->u.bad_arg = -1;
  1320.       return;
  1321.     }
  1322.       else
  1323.     ellipsis_strikes += list_length (tta);
  1324.     }
  1325.   else if (ttf && ttf != void_list_node)
  1326.     {
  1327.       /* ran out of actuals, and no defaults.  */
  1328.       if (TREE_PURPOSE (ttf) == NULL_TREE)
  1329.     {
  1330.       cp->h.code = EVIL_CODE;
  1331.       cp->u.bad_arg = -2;
  1332.       return;
  1333.     }
  1334.       /* Store index of first default.  */
  1335.       cp->v.ansi_harshness[arglen].distance = strike_index+1;
  1336.     }
  1337.   else
  1338.     cp->v.ansi_harshness[arglen].distance = 0;
  1339.  
  1340.   /* Argument list lengths work out, so don't need to check them again.  */
  1341.   if (evil_strikes)
  1342.     {
  1343.       /* We do not check for derived->base conversions here, since in
  1344.      no case would they give evil strike counts, unless such conversions
  1345.      are somehow ambiguous.  */
  1346.  
  1347.       /* See if any user-defined conversions apply.
  1348.          But make sure that we do not loop.  */
  1349.       static int dont_convert_types = 0;
  1350.  
  1351.       if (dont_convert_types)
  1352.     {
  1353.       cp->h.code = EVIL_CODE;
  1354.       return;
  1355.     }
  1356.  
  1357.       win = 0;            /* Only get one chance to win.  */
  1358.       ttf = TYPE_ARG_TYPES (TREE_TYPE (function));
  1359.       tta = tta_in;
  1360.       strike_index = 0;
  1361.       evil_strikes = 0;
  1362.  
  1363.       while (ttf && tta)
  1364.     {
  1365.       if (ttf == void_list_node)
  1366.         break;
  1367.  
  1368.       lose = cp->v.ansi_harshness[strike_index];
  1369.       if ((lose.code & EVIL_CODE)
  1370.           || ((lose.code & STD_CODE) && lose.distance < 0))
  1371.         {
  1372.           tree actual_type = TREE_TYPE (TREE_VALUE (tta));
  1373.           tree formal_type = TREE_VALUE (ttf);
  1374.  
  1375.           dont_convert_types = 1;
  1376.  
  1377.           if (TREE_CODE (formal_type) == REFERENCE_TYPE)
  1378.         formal_type = TREE_TYPE (formal_type);
  1379.           if (TREE_CODE (actual_type) == REFERENCE_TYPE)
  1380.         actual_type = TREE_TYPE (actual_type);
  1381.  
  1382.           if (formal_type != error_mark_node
  1383.           && actual_type != error_mark_node)
  1384.         {
  1385.           formal_type = TYPE_MAIN_VARIANT (formal_type);
  1386.           actual_type = TYPE_MAIN_VARIANT (actual_type);
  1387.  
  1388.           if (TYPE_HAS_CONSTRUCTOR (formal_type))
  1389.             {
  1390.               /* If it has a constructor for this type,
  1391.              try to use it.  */
  1392.               /* @@ There is no way to save this result yet, so
  1393.              success is a NULL_TREE for now.  */
  1394.               if (convert_to_aggr (formal_type, TREE_VALUE (tta), 0, 1)
  1395.               != error_mark_node)
  1396.             win++;
  1397.             }
  1398.           if (TYPE_LANG_SPECIFIC (actual_type)
  1399.               && TYPE_HAS_CONVERSION (actual_type))
  1400.             {
  1401.               if (TREE_CODE (formal_type) == INTEGER_TYPE
  1402.               && TYPE_HAS_INT_CONVERSION (actual_type))
  1403.             win++;
  1404.               else if (TREE_CODE (formal_type) == REAL_TYPE
  1405.                    && TYPE_HAS_REAL_CONVERSION (actual_type))
  1406.             win++;
  1407.               else
  1408.             {
  1409.               tree conv;
  1410.               /* Don't issue warnings since we're only groping
  1411.                  around for the right answer, we haven't yet
  1412.                  committed to going with this solution.  */
  1413.               int old_inhibit_warnings = inhibit_warnings;
  1414.  
  1415.               inhibit_warnings = 1;
  1416.               conv = build_type_conversion (CALL_EXPR, TREE_VALUE (ttf), TREE_VALUE (tta), 0);
  1417.               inhibit_warnings = old_inhibit_warnings;
  1418.  
  1419.               if (conv)
  1420.                 {
  1421.                   if (conv == error_mark_node)
  1422.                 win += 2;
  1423.                   else
  1424.                 win++;
  1425.                 }
  1426.               else if (TREE_CODE (TREE_VALUE (ttf)) == REFERENCE_TYPE)
  1427.                 {
  1428.                   conv = build_type_conversion (CALL_EXPR, formal_type, TREE_VALUE (tta), 0);
  1429.                   if (conv)
  1430.                 {
  1431.                   if (conv == error_mark_node)
  1432.                     win += 2;
  1433.                   else
  1434.                     win++;
  1435.                 }
  1436.                 }
  1437.             }
  1438.             }
  1439.         }
  1440.           dont_convert_types = 0;
  1441.  
  1442.           if (win == 1)
  1443.         {
  1444.           user_strikes += 1;
  1445.           cp->v.ansi_harshness[strike_index].code = USER_CODE;
  1446.           win = 0;
  1447.         }
  1448.           else
  1449.         {
  1450.           if (cp->u.bad_arg > strike_index)
  1451.             cp->u.bad_arg = strike_index;
  1452.  
  1453.           evil_strikes = win ? 2 : 1;
  1454.           break;
  1455.         }
  1456.         }
  1457.  
  1458.       ttf = TREE_CHAIN (ttf);
  1459.       tta = TREE_CHAIN (tta);
  1460.       strike_index += 1;
  1461.     }
  1462.     }
  1463.  
  1464.   /* Const member functions get a small penalty because defaulting
  1465.      to const is less useful than defaulting to non-const. */
  1466.   /* This is bogus, it does not correspond to anything in the ARM.
  1467.      This code will be fixed when this entire section is rewritten
  1468.      to conform to the ARM.  (mrs)  */
  1469.   if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
  1470.     {
  1471.       if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (ttf_in))))
  1472.     {
  1473.       cp->v.ansi_harshness[0].code |= TRIVIAL_CODE;
  1474.       ++easy_strikes;
  1475.     }
  1476.       else
  1477.     {
  1478.       /* Calling a non-const member function from a const member function
  1479.          is probably invalid, but for now we let it only draw a warning.
  1480.          We indicate that such a mismatch has occurred by setting the
  1481.          harshness to a maximum value.  */
  1482.       if (TREE_CODE (TREE_TYPE (TREE_VALUE (tta_in))) == POINTER_TYPE
  1483.           && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (TREE_VALUE (tta_in))))))
  1484.         cp->v.ansi_harshness[0].code |= CONST_CODE;
  1485.     }
  1486.     }
  1487.  
  1488.   if (evil_strikes)
  1489.     cp->h.code = EVIL_CODE;
  1490.   if (ellipsis_strikes)
  1491.     cp->h.code |= ELLIPSIS_CODE;
  1492.   if (user_strikes)
  1493.     cp->h.code |= USER_CODE;
  1494. }
  1495.  
  1496. void
  1497. compute_conversion_costs_old (function, tta_in, cp, arglen)
  1498.      tree function;
  1499.      tree tta_in;
  1500.      struct candidate *cp;
  1501.      int arglen;
  1502. {
  1503.   tree ttf_in = TYPE_ARG_TYPES (TREE_TYPE (function));
  1504.   tree ttf = ttf_in;
  1505.   tree tta = tta_in;
  1506.  
  1507.   /* Start out with no strikes against.  */
  1508.   int evil_strikes = 0;
  1509.   int ellipsis_strikes = 0;
  1510.   int user_strikes = 0;
  1511.   int b_or_d_strikes = 0;
  1512.   int easy_strikes = 0;
  1513.  
  1514.   int strike_index = 0, win, lose;
  1515.  
  1516. #ifdef GATHER_STATISTICS
  1517.   n_compute_conversion_costs++;
  1518. #endif
  1519.  
  1520.   cp->function = function;
  1521.   cp->arg = tta ? TREE_VALUE (tta) : NULL_TREE;
  1522.   cp->u.bad_arg = 0;        /* optimistic!  */
  1523.  
  1524.   bzero (cp->v.old_harshness, (arglen+1) * sizeof (short));
  1525.  
  1526.   while (ttf && tta)
  1527.     {
  1528.       int harshness;
  1529.  
  1530.       if (ttf == void_list_node)
  1531.     break;
  1532.  
  1533.       if (type_unknown_p (TREE_VALUE (tta)))
  1534.     {      
  1535.       /* Must perform some instantiation here.  */
  1536.       tree rhs = TREE_VALUE (tta);
  1537.       tree lhstype = TREE_VALUE (ttf);
  1538.  
  1539.       /* Keep quiet about possible contravariance violations.  */
  1540.       int old_inhibit_warnings = inhibit_warnings;
  1541.       inhibit_warnings = 1;
  1542.  
  1543.       /* @@ This is to undo what `grokdeclarator' does to
  1544.          parameter types.  It really should go through
  1545.          something more general.  */
  1546.  
  1547.       TREE_TYPE (tta) = unknown_type_node;
  1548.       rhs = instantiate_type (lhstype, rhs, 0);
  1549.       inhibit_warnings = old_inhibit_warnings;
  1550.  
  1551.       if (TREE_CODE (rhs) == ERROR_MARK)
  1552.         harshness = 1;
  1553.       else
  1554.         {
  1555.           harshness = convert_harshness_old (lhstype, TREE_TYPE (rhs),
  1556.                          rhs);
  1557.           /* harshness |= 2; */
  1558.         }
  1559.     }
  1560.       else
  1561.     harshness = convert_harshness_old (TREE_VALUE (ttf),
  1562.                        TREE_TYPE (TREE_VALUE (tta)),
  1563.                        TREE_VALUE (tta));
  1564.  
  1565.       cp->v.old_harshness[strike_index] = harshness;
  1566.       if (EVIL_HARSHNESS (harshness)
  1567.       || CONTRAVARIANT_HARSHNESS (harshness))
  1568.     {
  1569.       cp->u.bad_arg = strike_index;
  1570.       evil_strikes = 1;
  1571.     }
  1572.      else if (ELLIPSIS_HARSHNESS (harshness))
  1573.     {
  1574.       ellipsis_strikes += 1;
  1575.     }
  1576. #if 0
  1577.       /* This is never set by `convert_harshness_old'.  */
  1578.       else if (USER_HARSHNESS (harshness))
  1579.     {
  1580.       user_strikes += 1;
  1581.     }
  1582. #endif
  1583.       else if (BASE_DERIVED_HARSHNESS (harshness))
  1584.     {
  1585.       b_or_d_strikes += INT_FROM_BD_HARSHNESS (harshness);
  1586.     }
  1587.       else
  1588.     easy_strikes += INT_FROM_EASY_HARSHNESS (harshness);
  1589.       ttf = TREE_CHAIN (ttf);
  1590.       tta = TREE_CHAIN (tta);
  1591.       strike_index += 1;
  1592.     }
  1593.  
  1594.   if (tta)
  1595.     {
  1596.       /* ran out of formals, and parmlist is fixed size.  */
  1597.       if (ttf /* == void_type_node */)
  1598.     {
  1599.       cp->evil = 1;
  1600.       cp->u.bad_arg = -1;
  1601.       return;
  1602.     }
  1603.       else ellipsis_strikes += list_length (tta);
  1604.     }
  1605.   else if (ttf && ttf != void_list_node)
  1606.     {
  1607.       /* ran out of actuals, and no defaults.  */
  1608.       if (TREE_PURPOSE (ttf) == NULL_TREE)
  1609.     {
  1610.       cp->evil = 1;
  1611.       cp->u.bad_arg = -2;
  1612.       return;
  1613.     }
  1614.       /* Store index of first default.  */
  1615.       cp->v.old_harshness[arglen] = strike_index+1;
  1616.     }
  1617.   else
  1618.     cp->v.old_harshness[arglen] = 0;
  1619.  
  1620.   /* Argument list lengths work out, so don't need to check them again.  */
  1621.   if (evil_strikes)
  1622.     {
  1623.       /* We do not check for derived->base conversions here, since in
  1624.      no case would they give evil strike counts, unless such conversions
  1625.      are somehow ambiguous.  */
  1626.  
  1627.       /* See if any user-defined conversions apply.
  1628.          But make sure that we do not loop.  */
  1629.       static int dont_convert_types = 0;
  1630.  
  1631.       if (dont_convert_types)
  1632.     {
  1633.       cp->evil = 1;
  1634.       return;
  1635.     }
  1636.  
  1637.       win = 0;            /* Only get one chance to win.  */
  1638.       ttf = TYPE_ARG_TYPES (TREE_TYPE (function));
  1639.       tta = tta_in;
  1640.       strike_index = 0;
  1641.       evil_strikes = 0;
  1642.  
  1643.       while (ttf && tta)
  1644.     {
  1645.       if (ttf == void_list_node)
  1646.         break;
  1647.  
  1648.       lose = cp->v.old_harshness[strike_index];
  1649.       if (EVIL_HARSHNESS (lose)
  1650.           || CONTRAVARIANT_HARSHNESS (lose))
  1651.         {
  1652.           tree actual_type = TREE_TYPE (TREE_VALUE (tta));
  1653.           tree formal_type = TREE_VALUE (ttf);
  1654.  
  1655.           dont_convert_types = 1;
  1656.  
  1657.           if (TREE_CODE (formal_type) == REFERENCE_TYPE)
  1658.         formal_type = TREE_TYPE (formal_type);
  1659.           if (TREE_CODE (actual_type) == REFERENCE_TYPE)
  1660.         actual_type = TREE_TYPE (actual_type);
  1661.  
  1662.           if (formal_type != error_mark_node
  1663.           && actual_type != error_mark_node)
  1664.         {
  1665.           formal_type = TYPE_MAIN_VARIANT (formal_type);
  1666.           actual_type = TYPE_MAIN_VARIANT (actual_type);
  1667.  
  1668.           if (TYPE_HAS_CONSTRUCTOR (formal_type))
  1669.             {
  1670.               /* If it has a constructor for this type, try to use it.  */
  1671.               if (convert_to_aggr (formal_type, TREE_VALUE (tta), 0, 1)
  1672.               != error_mark_node)
  1673.             {
  1674.               /* @@ There is no way to save this result yet.
  1675.                  @@ So success is NULL_TREE for now.  */
  1676.               win++;
  1677.             }
  1678.             }
  1679.           if (TYPE_LANG_SPECIFIC (actual_type) && TYPE_HAS_CONVERSION (actual_type))
  1680.             {
  1681.               if (TREE_CODE (formal_type) == INTEGER_TYPE
  1682.               && TYPE_HAS_INT_CONVERSION (actual_type))
  1683.             win++;
  1684.               else if (TREE_CODE (formal_type) == REAL_TYPE
  1685.                    && TYPE_HAS_REAL_CONVERSION (actual_type))
  1686.             win++;
  1687.               else
  1688.             {
  1689.               tree conv = build_type_conversion (CALL_EXPR, TREE_VALUE (ttf), TREE_VALUE (tta), 0);
  1690.               if (conv)
  1691.                 {
  1692.                   if (conv == error_mark_node)
  1693.                 win += 2;
  1694.                   else
  1695.                 win++;
  1696.                 }
  1697.               else if (TREE_CODE (TREE_VALUE (ttf)) == REFERENCE_TYPE)
  1698.                 {
  1699.                   conv = build_type_conversion (CALL_EXPR, formal_type, TREE_VALUE (tta), 0);
  1700.                   if (conv)
  1701.                 {
  1702.                   if (conv == error_mark_node)
  1703.                     win += 2;
  1704.                   else
  1705.                     win++;
  1706.                 }
  1707.                 }
  1708.             }
  1709.             }
  1710.         }
  1711.           dont_convert_types = 0;
  1712.  
  1713.           if (win == 1)
  1714.         {
  1715.           user_strikes += 1;
  1716.           cp->v.old_harshness[strike_index] = USER_HARSHNESS (-1);
  1717.           win = 0;
  1718.         }
  1719.           else
  1720.         {
  1721.           if (cp->u.bad_arg > strike_index)
  1722.             cp->u.bad_arg = strike_index;
  1723.  
  1724.           evil_strikes = win ? 2 : 1;
  1725.           break;
  1726.         }
  1727.         }
  1728.  
  1729.       ttf = TREE_CHAIN (ttf);
  1730.       tta = TREE_CHAIN (tta);
  1731.       strike_index += 1;
  1732.     }
  1733.     }
  1734.  
  1735.   /* Const member functions get a small penalty because defaulting
  1736.      to const is less useful than defaulting to non-const. */
  1737.   /* This is bogus, it does not correspond to anything in the ARM.
  1738.      This code will be fixed when this entire section is rewritten
  1739.      to conform to the ARM.  (mrs)  */
  1740.   if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
  1741.     {
  1742.       if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (ttf_in))))
  1743.     {
  1744.       cp->v.old_harshness[0] += INT_TO_EASY_HARSHNESS (1);
  1745.       ++easy_strikes;
  1746.     }
  1747.       else
  1748.     {
  1749.       /* Calling a non-const member function from a const member function
  1750.          is probably invalid, but for now we let it only draw a warning.
  1751.          We indicate that such a mismatch has occurred by setting the
  1752.          harshness to a maximum value.  */
  1753.       if (TREE_CODE (TREE_TYPE (TREE_VALUE (tta_in))) == POINTER_TYPE
  1754.           && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (TREE_VALUE (tta_in))))))
  1755.         cp->v.old_harshness[0] |= CONST_HARSHNESS (-1);
  1756.     }
  1757.     }
  1758.  
  1759.   cp->evil = evil_strikes;
  1760.   cp->ellipsis = ellipsis_strikes;
  1761.   cp->user = user_strikes;
  1762.   cp->b_or_d = b_or_d_strikes;
  1763.   cp->easy = easy_strikes;
  1764. }
  1765.  
  1766. void
  1767. compute_conversion_costs (function, tta_in, cp, arglen)
  1768.      tree function;
  1769.      tree tta_in;
  1770.      struct candidate *cp;
  1771.      int arglen;
  1772. {
  1773.   if (flag_ansi_overloading)
  1774.     compute_conversion_costs_ansi (function, tta_in, cp, arglen);
  1775.   else
  1776.     compute_conversion_costs_old (function, tta_in, cp, arglen);
  1777. }
  1778.  
  1779. /* When one of several possible overloaded functions and/or methods
  1780.    can be called, choose the best candidate for overloading.
  1781.  
  1782.    BASETYPE is the context from which we start method resolution
  1783.    or NULL if we are comparing overloaded functions.
  1784.    CANDIDATES is the array of candidates we have to choose from.
  1785.    N_CANDIDATES is the length of CANDIDATES.
  1786.    PARMS is a TREE_LIST of parameters to the function we'll ultimately
  1787.    choose.  It is modified in place when resolving methods.  It is not
  1788.    modified in place when resolving overloaded functions.
  1789.    LEN is the length of the parameter list.  */
  1790.  
  1791. static struct candidate *
  1792. ideal_candidate_old (basetype, candidates, n_candidates, parms, len)
  1793.      tree basetype;
  1794.      struct candidate *candidates;
  1795.      int n_candidates;
  1796.      tree parms;
  1797.      int len;
  1798. {
  1799.   struct candidate *cp = candidates + n_candidates;
  1800.   int index, i;
  1801.   tree ttf;
  1802.  
  1803.   qsort (candidates,        /* char *base */
  1804.      n_candidates,        /* int nel */
  1805.      sizeof (struct candidate), /* int width */
  1806.      rank_for_overload);    /* int (*compar)() */
  1807.  
  1808.   /* If the best candidate requires user-defined conversions,
  1809.      and its user-defined conversions are a strict subset
  1810.      of all other candidates requiring user-defined conversions,
  1811.      then it is, in fact, the best.  */
  1812.   for (i = -1; cp + i != candidates; i--)
  1813.     if (cp[i].user == 0)
  1814.       break;
  1815.  
  1816.   if (i < -1)
  1817.     {
  1818.       tree ttf0;
  1819.  
  1820.       /* Check that every other candidate requires those conversions
  1821.      as a strict subset of their conversions.  */
  1822.       if (cp[i].user == cp[-1].user)
  1823.     goto non_subset;
  1824.  
  1825.       /* Look at subset relationship more closely.  */
  1826.       while (i != -1)
  1827.     {
  1828.       for (ttf = TYPE_ARG_TYPES (TREE_TYPE (cp[i].function)),
  1829.            ttf0 = TYPE_ARG_TYPES (TREE_TYPE (cp[-1].function)),
  1830.            index = 0; index < len; index++)
  1831.         {
  1832.           if (USER_HARSHNESS (cp[i].v.old_harshness[index]))
  1833.         {
  1834.           /* If our "best" candidate also needs a conversion,
  1835.              it must be the same one.  */
  1836.           if (USER_HARSHNESS (cp[-1].v.old_harshness[index])
  1837.               && TREE_VALUE (ttf) != TREE_VALUE (ttf0))
  1838.             goto non_subset;
  1839.         }
  1840.           ttf = TREE_CHAIN (ttf);
  1841.           ttf0 = TREE_CHAIN (ttf0);
  1842.           /* Handle `...' gracefully.  */
  1843.           if (ttf == NULL_TREE || ttf0 == NULL_TREE)
  1844.         break;
  1845.         }
  1846.       i++;
  1847.     }
  1848.       /* The best was the best.  */
  1849.       return cp - 1;
  1850.     non_subset:
  1851.       /* Use other rules for determining "bestness".  */
  1852.       ;
  1853.     }
  1854.  
  1855.   /* If the best two candidates we find require user-defined
  1856.      conversions, we may need to report and error message.  */
  1857.   if (cp[-1].user && cp[-2].user
  1858.       && (cp[-1].b_or_d || cp[-2].b_or_d == 0))
  1859.     {
  1860.       /* If the best two methods found involved user-defined
  1861.      type conversions, then we must see whether one
  1862.      of them is exactly what we wanted.  If not, then
  1863.      we have an ambiguity.  */
  1864.       int best = 0;
  1865.       tree tta = parms;
  1866.       tree f1;
  1867. #if 0
  1868.       /* for LUCID */
  1869.       tree p1;
  1870. #endif
  1871.  
  1872.       /* Stash all of our parameters in safe places
  1873.      so that we can perform type conversions in place.  */
  1874.       while (tta)
  1875.     {
  1876.       TREE_PURPOSE (tta) = TREE_VALUE (tta);
  1877.       tta = TREE_CHAIN (tta);
  1878.     }
  1879.  
  1880.       i = 0;
  1881.       do
  1882.     {
  1883.       int exact_conversions = 0;
  1884.  
  1885.       i -= 1;
  1886.       tta = parms;
  1887.       if (DECL_STATIC_FUNCTION_P (cp[i].function))
  1888.         tta = TREE_CHAIN (tta);
  1889.       /* special note, we don't go through len parameters, because we
  1890.          may only need len-1 parameters because of a call to a static
  1891.          member. */
  1892.       for (ttf = TYPE_ARG_TYPES (TREE_TYPE (cp[i].function)), index = 0;
  1893.            tta;
  1894.            tta = TREE_CHAIN (tta), ttf = TREE_CHAIN (ttf), index++)
  1895.         {
  1896.           /* If this is a varargs function, there's no conversion to do,
  1897.          but don't accept an arg that needs a copy ctor.  */
  1898.           if (ttf == NULL_TREE)
  1899.         {
  1900.           /* FIXME: verify that we cannot get here with an
  1901.              arg that needs a ctor.  */
  1902.           break;
  1903.         }
  1904.  
  1905.           if (USER_HARSHNESS (cp[i].v.old_harshness[index]))
  1906.         {
  1907.           tree this_parm = build_type_conversion (CALL_EXPR, TREE_VALUE (ttf), TREE_PURPOSE (tta), 2);
  1908.           if (basetype != NULL_TREE)
  1909.             TREE_VALUE (tta) = this_parm;
  1910.           if (this_parm)
  1911.             {
  1912.               if (TREE_CODE (this_parm) != CONVERT_EXPR
  1913.               && (TREE_CODE (this_parm) != NOP_EXPR
  1914.                   || comp_target_types (TREE_TYPE (this_parm),
  1915.                             TREE_TYPE (TREE_OPERAND (this_parm, 0)), 1)))
  1916.             exact_conversions += 1;
  1917.             }
  1918.           else if (PROMOTES_TO_AGGR_TYPE (TREE_VALUE (ttf), REFERENCE_TYPE))
  1919.             {
  1920.               /* To get here we had to have succeeded via
  1921.              a constructor.  */
  1922.               TREE_VALUE (tta) = TREE_PURPOSE (tta);
  1923.               exact_conversions += 1;
  1924.             }
  1925.         }
  1926.         }
  1927.       if (exact_conversions == cp[i].user)
  1928.         {
  1929.           if (best == 0)
  1930.         {
  1931.           best = i;
  1932.           f1 = cp[best].function;
  1933. #if 0
  1934.           /* For LUCID */
  1935.           p1 = TYPE_ARG_TYPES (TREE_TYPE (f1));
  1936. #endif
  1937.         }
  1938.           else
  1939.         {
  1940.           /* Don't complain if next best is from base class.  */
  1941.           tree f2 = cp[i].function;
  1942.  
  1943.           if (TREE_CODE (TREE_TYPE (f1)) == METHOD_TYPE
  1944.               && TREE_CODE (TREE_TYPE (f2)) == METHOD_TYPE
  1945.               && BASE_DERIVED_HARSHNESS (cp[i].v.old_harshness[0])
  1946.               && cp[best].v.old_harshness[0] < cp[i].v.old_harshness[0])
  1947.             {
  1948. #if 0
  1949.               tree p2 = TYPE_ARG_TYPES (TREE_TYPE (f2));
  1950.               /* For LUCID.  */
  1951.               if (! compparms (TREE_CHAIN (p1), TREE_CHAIN (p2), 1))
  1952.             goto ret0;
  1953.               else
  1954. #endif
  1955.             continue;
  1956.             }
  1957.           else
  1958.             {
  1959.               /* Ensure that there's nothing ambiguous about these
  1960.              two fns.  */
  1961.               int identical = 1;
  1962.               for (index = 0; index < len; index++)
  1963.             {
  1964.               /* Type conversions must be piecewise equivalent.  */
  1965.               if (USER_HARSHNESS (cp[best].v.old_harshness[index])
  1966.                   != USER_HARSHNESS (cp[i].v.old_harshness[index]))
  1967.                 goto ret0;
  1968.               /* If there's anything we like better about the
  1969.                  other function, consider it ambiguous.  */
  1970.               if (cp[i].v.old_harshness[index] < cp[best].v.old_harshness[index])
  1971.                 goto ret0;
  1972.               /* If any single one it diffent, then the whole is
  1973.                  not identical.  */
  1974.               if (cp[i].v.old_harshness[index] != cp[best].v.old_harshness[index])
  1975.                 identical = 0;
  1976.             }
  1977.  
  1978.               /* If we can't tell the difference between the two, it
  1979.              is ambiguous.  */
  1980.               if (identical)
  1981.             goto ret0;
  1982.  
  1983.               /* If we made it to here, it means we're satisfied that
  1984.              BEST is still best.  */
  1985.               continue;
  1986.             }
  1987.         }
  1988.         }
  1989.     } while (cp + i != candidates);
  1990.  
  1991.       if (best)
  1992.     {
  1993.       int exact_conversions = cp[best].user;
  1994.       tta = parms;
  1995.       if (DECL_STATIC_FUNCTION_P (cp[best].function))
  1996.         tta = TREE_CHAIN (parms);
  1997.       for (ttf = TYPE_ARG_TYPES (TREE_TYPE (cp[best].function)), index = 0;
  1998.            exact_conversions > 0;
  1999.            tta = TREE_CHAIN (tta), ttf = TREE_CHAIN (ttf), index++)
  2000.         {
  2001.           if (USER_HARSHNESS (cp[best].v.old_harshness[index]))
  2002.         {
  2003.           /* We must now fill in the slot we left behind.
  2004.              @@ This could be optimized to use the value previously
  2005.              @@ computed by build_type_conversion in some cases.  */
  2006.           if (basetype != NULL_TREE)
  2007.             TREE_VALUE (tta) = convert (TREE_VALUE (ttf), TREE_PURPOSE (tta));
  2008.           exact_conversions -= 1;
  2009.         }
  2010.           else
  2011.         TREE_VALUE (tta) = TREE_PURPOSE (tta);
  2012.         }
  2013.       return cp + best;
  2014.     }
  2015.       goto ret0;
  2016.     }
  2017.   /* If the best two candidates we find both use default parameters,
  2018.      we may need to report and error.  Don't need to worry if next-best
  2019.      candidate is forced to use user-defined conversion when best is not.  */
  2020.   if (cp[-2].user == 0
  2021.       && cp[-1].v.old_harshness[len] != 0 && cp[-2].v.old_harshness[len] != 0)
  2022.     {
  2023.       tree tt1 = TYPE_ARG_TYPES (TREE_TYPE (cp[-1].function));
  2024.       tree tt2 = TYPE_ARG_TYPES (TREE_TYPE (cp[-2].function));
  2025.       unsigned i = cp[-1].v.old_harshness[len];
  2026.  
  2027.       if (cp[-2].v.old_harshness[len] < i)
  2028.     i = cp[-2].v.old_harshness[len];
  2029.       while (--i > 0)
  2030.     {
  2031.       if (TYPE_MAIN_VARIANT (TREE_VALUE (tt1))
  2032.           != TYPE_MAIN_VARIANT (TREE_VALUE (tt2)))
  2033.         /* These lists are not identical, so we can choose our best candidate.  */
  2034.         return cp - 1;
  2035.       tt1 = TREE_CHAIN (tt1);
  2036.       tt2 = TREE_CHAIN (tt2);
  2037.     }
  2038.       /* To get here, both lists had the same parameters up to the defaults
  2039.      which were used.  This is an ambiguous request.  */
  2040.       goto ret0;
  2041.     }
  2042.  
  2043.   /* Otherwise, return our best candidate.  Note that if we get candidates
  2044.      from independent base classes, we have an ambiguity, even if one
  2045.      argument list look a little better than another one.  */
  2046.   if (cp[-1].b_or_d && basetype && TYPE_USES_MULTIPLE_INHERITANCE (basetype))
  2047.     {
  2048.       int i = n_candidates - 1, best = i;
  2049.       tree base1 = NULL_TREE;
  2050.  
  2051.       if (TREE_CODE (TREE_TYPE (candidates[i].function)) == FUNCTION_TYPE)
  2052.     return cp - 1;
  2053.  
  2054.       for (; i >= 0 && candidates[i].user == 0 && candidates[i].evil == 0; i--)
  2055.     {
  2056.       if (TREE_CODE (TREE_TYPE (candidates[i].function)) == METHOD_TYPE)
  2057.         {
  2058.           tree newbase = DECL_CLASS_CONTEXT (candidates[i].function);
  2059.  
  2060.           if (base1 != NULL_TREE)
  2061.         {
  2062.           /* newbase could be a base or a parent of base1 */
  2063.           if (newbase != base1 && ! UNIQUELY_DERIVED_FROM_P (newbase, base1)
  2064.               && ! UNIQUELY_DERIVED_FROM_P (base1, newbase))
  2065.             {
  2066.               cp_error ("ambiguous request for function from distinct base classes of type `%T'", basetype);
  2067.               cp_error_at ("  first candidate is `%#D'",
  2068.                      candidates[best].function);
  2069.               cp_error_at ("  second candidate is `%#D'",
  2070.                      candidates[i].function);
  2071.               cp[-1].evil = 1;
  2072.               return cp - 1;
  2073.             }
  2074.         }
  2075.           else
  2076.         {
  2077.           best = i;
  2078.           base1 = newbase;
  2079.         }
  2080.         }
  2081.       else
  2082.         return cp - 1;
  2083.     }
  2084.     }
  2085.  
  2086.   /* Don't accept a candidate as being ideal if it's indistinguishable
  2087.      from another candidate.  */
  2088.   if (rank_for_overload (cp-1, cp-2) == 0)
  2089.     {
  2090.       /* If the types are distinguishably different (like
  2091.      `long' vs. `unsigned long'), that's ok.  But if they are arbitrarily
  2092.      different, such as `int (*)(void)' vs. `void (*)(int)',
  2093.      that's not ok.  */
  2094.       tree p1 = TYPE_ARG_TYPES (TREE_TYPE (cp[-1].function));
  2095.       tree p2 = TYPE_ARG_TYPES (TREE_TYPE (cp[-2].function));
  2096.       while (p1 && p2)
  2097.     {
  2098.       if (TREE_CODE (TREE_VALUE (p1)) == POINTER_TYPE
  2099.           && TREE_CODE (TREE_TYPE (TREE_VALUE (p1))) == FUNCTION_TYPE
  2100.           && TREE_VALUE (p1) != TREE_VALUE (p2))
  2101.         return NULL;
  2102.       p1 = TREE_CHAIN (p1);
  2103.       p2 = TREE_CHAIN (p2);
  2104.     }
  2105.       if (p1 || p2)
  2106.     return NULL;
  2107.     }
  2108.  
  2109.   return cp - 1;
  2110.  
  2111.  ret0:
  2112.   /* In the case where there is no ideal candidate, restore
  2113.      TREE_VALUE slots of PARMS from TREE_PURPOSE slots.  */
  2114.   while (parms)
  2115.     {
  2116.       TREE_VALUE (parms) = TREE_PURPOSE (parms);
  2117.       parms = TREE_CHAIN (parms);
  2118.     }
  2119.   return NULL;
  2120. }
  2121.  
  2122. /* Subroutine of ideal_candidate.  See if X or Y is a better match
  2123.    than the other.  */
  2124. static int
  2125. strictly_better (x, y)
  2126.      unsigned short x, y;
  2127. {
  2128.   unsigned short xor;
  2129.  
  2130.   if (x == y)
  2131.     return 0;
  2132.  
  2133.   xor = x ^ y;
  2134.   if (xor >= x || xor >= y)
  2135.     return 1;
  2136.   return 0;
  2137. }
  2138.  
  2139. static struct candidate *
  2140. ideal_candidate_ansi (basetype, candidates, n_candidates, parms, len)
  2141.      tree basetype;
  2142.      struct candidate *candidates;
  2143.      int n_candidates;
  2144.      tree parms;
  2145.      int len;
  2146. {
  2147.   struct candidate *cp = candidates+n_candidates;
  2148.   int i, j, best_code;
  2149.  
  2150.   /* For each argument, sort the functions from best to worst for the arg.
  2151.      For each function that's not best for this arg, set its overall
  2152.      harshness to EVIL so that other args won't like it.  The candidate
  2153.      list for the last argument is the intersection of all the best-liked
  2154.      functions.  */
  2155.  
  2156.   for (i = 0; i < len; i++)
  2157.     {
  2158.       qsort (candidates, n_candidates, sizeof (struct candidate),
  2159.          rank_for_overload);
  2160.       best_code = cp[-1].h.code;
  2161.  
  2162.       /* To find out functions that are worse than that represented
  2163.      by BEST_CODE, we can't just do a comparison like h.code>best_code.
  2164.      The total harshness for the "best" fn may be 8|8 for two args, and
  2165.      the harshness for the next-best may be 8|2.  If we just compared,
  2166.      that would be checking 8>10, which would lead to the next-best
  2167.      being disqualified.  What we actually want to do is get rid
  2168.      of functions that are definitely worse than that represented
  2169.      by best_code, i.e. those which have bits set higher than the
  2170.      highest in best_code.  Sooooo, what we do is clear out everything
  2171.      represented by best_code, and see if we still come up with something
  2172.      higher.  If so (e.g., 8|8 vs 8|16), it'll disqualify it properly.  */
  2173.       for (j = n_candidates-2; j >= 0; j--)
  2174.     if ((candidates[j].h.code & ~best_code) > best_code)
  2175.       candidates[j].h.code = EVIL_CODE;
  2176.     }
  2177.  
  2178.   if (cp[-1].h.code & EVIL_CODE)
  2179.     return NULL;
  2180.  
  2181.   /* If they're at least as good as each other, do an arg-by-arg check.  */
  2182.   if (! strictly_better (cp[-1].h.code, cp[-2].h.code))
  2183.     {
  2184.       int better = 0;
  2185.       int worse = 0;
  2186.  
  2187.       for (j = 0; j < n_candidates; j++)
  2188.     if (! strictly_better (candidates[j].h.code, best_code))
  2189.       break;
  2190.  
  2191.       qsort (candidates+j, n_candidates-j, sizeof (struct candidate),
  2192.          rank_for_ideal);
  2193.       for (i = 0; i < len; i++)
  2194.     {
  2195.       if (cp[-1].v.ansi_harshness[i].code < cp[-2].v.ansi_harshness[i].code)
  2196.         better = 1;
  2197.       else if (cp[-1].v.ansi_harshness[i].code > cp[-2].v.ansi_harshness[i].code)
  2198.         worse = 1;
  2199.       else if (cp[-1].v.ansi_harshness[i].code & STD_CODE)
  2200.         {
  2201.           /* If it involves a standard conversion, let the
  2202.          inheritance lattice be the final arbiter.  */
  2203.           if (cp[-1].v.ansi_harshness[i].distance > cp[-2].v.ansi_harshness[i].distance)
  2204.         worse = 1;
  2205.           else if (cp[-1].v.ansi_harshness[i].distance < cp[-2].v.ansi_harshness[i].distance)
  2206.         better = 1;
  2207.         }
  2208.       else if (cp[-1].v.ansi_harshness[i].code & PROMO_CODE)
  2209.         {
  2210.           /* For integral promotions, take into account a finer granularity for
  2211.          determining which types should be favored over others in such
  2212.          promotions.  */
  2213.           if (cp[-1].v.ansi_harshness[i].int_penalty > cp[-2].v.ansi_harshness[i].int_penalty)
  2214.         worse = 1;
  2215.           else if (cp[-1].v.ansi_harshness[i].int_penalty < cp[-2].v.ansi_harshness[i].int_penalty)
  2216.         better = 1;
  2217.         }
  2218.     }
  2219.  
  2220.       if (! better || worse)
  2221.     return NULL;
  2222.     }
  2223.   return cp-1;
  2224. }
  2225.  
  2226. static struct candidate *
  2227. ideal_candidate (basetype, candidates, n_candidates, parms, len)
  2228.      tree basetype;
  2229.      struct candidate *candidates;
  2230.      int n_candidates;
  2231.      tree parms;
  2232.      int len;
  2233. {
  2234.   if (flag_ansi_overloading)
  2235.     return ideal_candidate_ansi (basetype, candidates, n_candidates, parms,
  2236.                  len);
  2237.   else
  2238.     return ideal_candidate_old (basetype, candidates, n_candidates, parms,
  2239.                 len);
  2240. }
  2241.  
  2242. /* Assume that if the class referred to is not in the
  2243.    current class hierarchy, that it may be remote.
  2244.    PARENT is assumed to be of aggregate type here.  */
  2245. static int
  2246. may_be_remote (parent)
  2247.      tree parent;
  2248. {
  2249.   if (TYPE_OVERLOADS_METHOD_CALL_EXPR (parent) == 0)
  2250.     return 0;
  2251.  
  2252.   if (current_class_type == NULL_TREE)
  2253.     return 0;
  2254.  
  2255.   if (parent == current_class_type)
  2256.     return 0;
  2257.  
  2258.   if (UNIQUELY_DERIVED_FROM_P (parent, current_class_type))
  2259.     return 0;
  2260.   return 1;
  2261. }
  2262.  
  2263. tree
  2264. build_vfield_ref (datum, type)
  2265.      tree datum, type;
  2266. {
  2267.   tree rval;
  2268.   int old_assume_nonnull_objects = flag_assume_nonnull_objects;
  2269.  
  2270.   if (datum == error_mark_node)
  2271.     return error_mark_node;
  2272.  
  2273.   /* Vtable references are always made from non-null objects.  */
  2274.   flag_assume_nonnull_objects = 1;
  2275.   if (TREE_CODE (TREE_TYPE (datum)) == REFERENCE_TYPE)
  2276.     datum = convert_from_reference (datum);
  2277.  
  2278.   if (! TYPE_USES_COMPLEX_INHERITANCE (type))
  2279.     rval = build (COMPONENT_REF, TREE_TYPE (CLASSTYPE_VFIELD (type)),
  2280.           datum, CLASSTYPE_VFIELD (type));
  2281.   else
  2282.     rval = build_component_ref (datum, DECL_NAME (CLASSTYPE_VFIELD (type)), 0, 0);
  2283.   flag_assume_nonnull_objects = old_assume_nonnull_objects;
  2284.  
  2285.   return rval;
  2286. }
  2287.  
  2288. /* Build a call to a member of an object.  I.e., one that overloads
  2289.    operator ()(), or is a pointer-to-function or pointer-to-method.  */
  2290. static tree
  2291. build_field_call (basetype_path, instance_ptr, name, parms, err_name)
  2292.      tree basetype_path, instance_ptr, name, parms;
  2293.      char *err_name;
  2294. {
  2295.   tree field, instance;
  2296.  
  2297.   if (instance_ptr == current_class_decl)
  2298.     {
  2299.       /* Check to see if we really have a reference to an instance variable
  2300.      with `operator()()' overloaded.  */
  2301.       field = IDENTIFIER_CLASS_VALUE (name);
  2302.  
  2303.       if (field == NULL_TREE)
  2304.     {
  2305.       error ("`this' has no member named `%s'", err_name);
  2306.       return error_mark_node;
  2307.     }
  2308.  
  2309.       if (TREE_CODE (field) == FIELD_DECL)
  2310.     {
  2311.       /* If it's a field, try overloading operator (),
  2312.          or calling if the field is a pointer-to-function.  */
  2313.       instance = build_component_ref_1 (C_C_D, field, 0);
  2314.       if (instance == error_mark_node)
  2315.         return error_mark_node;
  2316.  
  2317.       if (TYPE_LANG_SPECIFIC (TREE_TYPE (instance))
  2318.           && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (instance)))
  2319.         return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, instance, parms, NULL_TREE);
  2320.  
  2321.       if (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE)
  2322.         {
  2323.           if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance))) == FUNCTION_TYPE)
  2324.         return build_function_call (instance, parms);
  2325.           else if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance))) == METHOD_TYPE)
  2326.         return build_function_call (instance, tree_cons (NULL_TREE, current_class_decl, parms));
  2327.         }
  2328.     }
  2329.       return NULL_TREE;
  2330.     }
  2331.  
  2332.   /* Check to see if this is not really a reference to an instance variable
  2333.      with `operator()()' overloaded.  */
  2334.   field = lookup_field (basetype_path, name, 1, 0);
  2335.  
  2336.   /* This can happen if the reference was ambiguous
  2337.      or for visibility violations.  */
  2338.   if (field == error_mark_node)
  2339.     return error_mark_node;
  2340.  
  2341.   if (field)
  2342.     {
  2343.       tree basetype;
  2344.       tree ftype = TREE_TYPE (field);
  2345.  
  2346.       if (TREE_CODE (ftype) == REFERENCE_TYPE)
  2347.     ftype = TREE_TYPE (ftype);
  2348.  
  2349.       if (TYPE_LANG_SPECIFIC (ftype) && TYPE_OVERLOADS_CALL_EXPR (ftype))
  2350.     {
  2351.       /* Make the next search for this field very short.  */
  2352.       basetype = DECL_FIELD_CONTEXT (field);
  2353.       instance_ptr = convert_pointer_to (basetype, instance_ptr);
  2354.  
  2355.       instance = build_indirect_ref (instance_ptr, NULL_PTR);
  2356.       return build_opfncall (CALL_EXPR, LOOKUP_NORMAL,
  2357.                  build_component_ref_1 (instance, field, 0),
  2358.                  parms, NULL_TREE);
  2359.     }
  2360.       if (TREE_CODE (ftype) == POINTER_TYPE)
  2361.     {
  2362.       if (TREE_CODE (TREE_TYPE (ftype)) == FUNCTION_TYPE
  2363.           || TREE_CODE (TREE_TYPE (ftype)) == METHOD_TYPE)
  2364.         {
  2365.           /* This is a member which is a pointer to function.  */
  2366.           tree ref
  2367.         = build_component_ref_1 (build_indirect_ref (instance_ptr,
  2368.                                  NULL_PTR),
  2369.                      field, LOOKUP_COMPLAIN);
  2370.           if (ref == error_mark_node)
  2371.         return error_mark_node;
  2372.           return build_function_call (ref, parms);
  2373.         }
  2374.     }
  2375.       else if (TREE_CODE (ftype) == METHOD_TYPE)
  2376.     {
  2377.       error ("invalid call via pointer-to-member function");
  2378.       return error_mark_node;
  2379.     }
  2380.       else
  2381.     return NULL_TREE;
  2382.     }
  2383.   return NULL_TREE;
  2384. }
  2385.  
  2386. tree
  2387. find_scoped_type (type, inner_name, inner_types)
  2388.      tree type, inner_name, inner_types;
  2389. {
  2390.   tree tags = CLASSTYPE_TAGS (type);
  2391.  
  2392.   while (tags)
  2393.     {
  2394.       /* The TREE_PURPOSE of an enum tag (which becomes a member of the
  2395.      enclosing class) is set to the name for the enum type.  So, if
  2396.      inner_name is `bar', and we strike `baz' for `enum bar { baz }',
  2397.      then this test will be true.  */
  2398.       if (TREE_PURPOSE (tags) == inner_name)
  2399.     {
  2400.       if (inner_types == NULL_TREE)
  2401.         return DECL_NESTED_TYPENAME (TYPE_NAME (TREE_VALUE (tags)));
  2402.       return resolve_scope_to_name (TREE_VALUE (tags), inner_types);
  2403.     }
  2404.       tags = TREE_CHAIN (tags);
  2405.     }
  2406.  
  2407. #if 0
  2408.   /* XXX This needs to be fixed better.  */
  2409.   if (TREE_CODE (type) == UNINSTANTIATED_P_TYPE)
  2410.     {
  2411.       sorry ("nested class lookup in template type");
  2412.       return NULL_TREE;
  2413.     }
  2414. #endif
  2415.  
  2416.   /* Look for a TYPE_DECL.  */
  2417.   for (tags = TYPE_FIELDS (type); tags; tags = TREE_CHAIN (tags))
  2418.     if (TREE_CODE (tags) == TYPE_DECL && DECL_NAME (tags) == inner_name)
  2419.       {
  2420.     /* Code by raeburn.  */
  2421.     if (inner_types == NULL_TREE)
  2422.       return DECL_NESTED_TYPENAME (tags);
  2423.     return resolve_scope_to_name (TREE_TYPE (tags), inner_types);
  2424.       }
  2425.  
  2426.   return NULL_TREE;
  2427. }
  2428.  
  2429. /* Resolve an expression NAME1::NAME2::...::NAMEn to
  2430.    the name that names the above nested type.  INNER_TYPES
  2431.    is a chain of nested type names (held together by SCOPE_REFs);
  2432.    OUTER_TYPE is the type we know to enclose INNER_TYPES.
  2433.    Returns NULL_TREE if there is an error.  */
  2434. tree
  2435. resolve_scope_to_name (outer_type, inner_types)
  2436.      tree outer_type, inner_types;
  2437. {
  2438.   register tree tmp;
  2439.   tree inner_name;
  2440.  
  2441.   if (outer_type == NULL_TREE && current_class_type != NULL_TREE)
  2442.     {
  2443.       /* We first try to look for a nesting in our current class context,
  2444.          then try any enclosing classes.  */
  2445.       tree type = current_class_type;
  2446.       
  2447.       while (type && (TREE_CODE (type) == RECORD_TYPE
  2448.               || TREE_CODE (type) == UNION_TYPE))
  2449.         {
  2450.           tree rval = resolve_scope_to_name (type, inner_types);
  2451.  
  2452.       if (rval != NULL_TREE)
  2453.         return rval;
  2454.       type = DECL_CONTEXT (TYPE_NAME (type));
  2455.     }
  2456.     }
  2457.  
  2458.   if (TREE_CODE (inner_types) == SCOPE_REF)
  2459.     {
  2460.       inner_name = TREE_OPERAND (inner_types, 0);
  2461.       inner_types = TREE_OPERAND (inner_types, 1);
  2462.     }
  2463.   else
  2464.     {
  2465.       inner_name = inner_types;
  2466.       inner_types = NULL_TREE;
  2467.     }
  2468.  
  2469.   if (outer_type == NULL_TREE)
  2470.     {
  2471.       /* If we have something that's already a type by itself,
  2472.      use that.  */
  2473.       if (IDENTIFIER_HAS_TYPE_VALUE (inner_name))
  2474.     {
  2475.       if (inner_types)
  2476.         return resolve_scope_to_name (IDENTIFIER_TYPE_VALUE (inner_name),
  2477.                       inner_types);
  2478.       return inner_name;
  2479.     }
  2480.       return NULL_TREE;
  2481.     }
  2482.  
  2483.   if (! IS_AGGR_TYPE (outer_type))
  2484.     return NULL_TREE;
  2485.  
  2486.   /* Look for member classes or enums.  */
  2487.   tmp = find_scoped_type (outer_type, inner_name, inner_types);
  2488.  
  2489.   /* If it's not a type in this class, then go down into the
  2490.      base classes and search there.  */
  2491.   if (! tmp && TYPE_BINFO (outer_type))
  2492.     {
  2493.       tree binfos = TYPE_BINFO_BASETYPES (outer_type);
  2494.       int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
  2495.  
  2496.       for (i = 0; i < n_baselinks; i++)
  2497.     {
  2498.       tree base_binfo = TREE_VEC_ELT (binfos, i);
  2499.       tmp = find_scoped_type (BINFO_TYPE (base_binfo),
  2500.                   inner_name, inner_types);
  2501.       if (tmp)
  2502.         return tmp;
  2503.     }
  2504.       tmp = NULL_TREE;
  2505.     }
  2506.  
  2507.   return tmp;
  2508. }
  2509.  
  2510. /* Build a method call of the form `EXP->SCOPES::NAME (PARMS)'.
  2511.    This is how virtual function calls are avoided.  */
  2512. tree
  2513. build_scoped_method_call (exp, scopes, name, parms)
  2514.      tree exp, scopes, name, parms;
  2515. {
  2516.   /* Because this syntactic form does not allow
  2517.      a pointer to a base class to be `stolen',
  2518.      we need not protect the derived->base conversion
  2519.      that happens here.
  2520.      
  2521.      @@ But we do have to check visibility privileges later.  */
  2522.   tree basename = resolve_scope_to_name (NULL_TREE, scopes);
  2523.   tree basetype, binfo, decl;
  2524.   tree type = TREE_TYPE (exp);
  2525.  
  2526.   if (type == error_mark_node
  2527.       || basename == NULL_TREE)
  2528.     return error_mark_node;
  2529.  
  2530.   basetype = IDENTIFIER_TYPE_VALUE (basename);
  2531.  
  2532.   if (TREE_CODE (type) == REFERENCE_TYPE)
  2533.     type = TREE_TYPE (type);
  2534.  
  2535.   /* Destructors can be "called" for simple types; see 5.2.4 and 12.4 Note
  2536.      that explicit ~int is caught in the parser; this deals with typedefs
  2537.      and template parms.  */
  2538.   if (TREE_CODE (name) == BIT_NOT_EXPR && ! is_aggr_typedef (basename, 0))
  2539.     {
  2540.       if (type != basetype)
  2541.     cp_error ("type of `%E' does not match destructor type `%T' (type was `%T')",
  2542.           exp, basetype, type);
  2543.       name = IDENTIFIER_TYPE_VALUE (TREE_OPERAND (name, 0));
  2544.       if (basetype != name)
  2545.     cp_error ("qualified type `%T' does not match destructor type `%T'",
  2546.           basetype, name);
  2547.       return void_zero_node;
  2548.     }
  2549.  
  2550.   if (! is_aggr_typedef (basename, 1))
  2551.     return error_mark_node;
  2552.  
  2553.   if (! IS_AGGR_TYPE (type))
  2554.     {
  2555.       cp_error ("base object `%E' of scoped method call is of non-aggregate type `%T'",
  2556.         exp, type);
  2557.       return error_mark_node;
  2558.     }
  2559.  
  2560.   if (binfo = binfo_or_else (basetype, type))
  2561.     {
  2562.       if (binfo == error_mark_node)
  2563.     return error_mark_node;
  2564.       if (TREE_CODE (exp) == INDIRECT_REF)
  2565.     decl = build_indirect_ref (convert_pointer_to (binfo,
  2566.                                build_unary_op (ADDR_EXPR, exp, 0)), NULL_PTR);
  2567.       else
  2568.     decl = build_scoped_ref (exp, scopes);
  2569.  
  2570.       /* Call to a destructor.  */
  2571.       if (TREE_CODE (name) == BIT_NOT_EXPR)
  2572.     {
  2573.       /* Explicit call to destructor.  */
  2574.       name = TREE_OPERAND (name, 0);
  2575.       if (TREE_TYPE (decl) !=
  2576.           (IDENTIFIER_CLASS_VALUE (name)
  2577.            ? IDENTIFIER_CLASS_TYPE_VALUE (name)
  2578.            : IDENTIFIER_TYPE_VALUE (name)))
  2579.         {
  2580.           cp_error
  2581.         ("qualified type `%T' does not match destructor type `%T'",
  2582.          TREE_TYPE (decl), name);
  2583.           return error_mark_node;
  2584.         }
  2585.       if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl)))
  2586.         return void_zero_node;
  2587.       
  2588.       return build_delete (TREE_TYPE (decl), decl, integer_two_node,
  2589.                    LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR,
  2590.                    0);
  2591.     }
  2592.  
  2593.       /* Call to a method.  */
  2594.       return build_method_call (decl, name, parms, NULL_TREE,
  2595.                 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL);
  2596.     }
  2597.   return error_mark_node;
  2598. }
  2599.  
  2600. /* Build something of the form ptr->method (args)
  2601.    or object.method (args).  This can also build
  2602.    calls to constructors, and find friends.
  2603.  
  2604.    Member functions always take their class variable
  2605.    as a pointer.
  2606.  
  2607.    INSTANCE is a class instance.
  2608.  
  2609.    NAME is the NAME field of the struct, union, or class
  2610.    whose type is that of INSTANCE.
  2611.  
  2612.    PARMS help to figure out what that NAME really refers to.
  2613.  
  2614.    BASETYPE_PATH, if non-NULL, tells which basetypes of INSTANCE
  2615.    we should be traversed before starting our search.  We need
  2616.    this information to get protected accesses correct.
  2617.  
  2618.    FLAGS is the logical disjunction of zero or more LOOKUP_
  2619.    flags.  See cp-tree.h for more info.
  2620.  
  2621.    If this is all OK, calls build_function_call with the resolved
  2622.    member function.
  2623.  
  2624.    This function must also handle being called to perform
  2625.    initialization, promotion/coercion of arguments, and
  2626.    instantiation of default parameters.
  2627.  
  2628.    Note that NAME may refer to an instance variable name.  If
  2629.    `operator()()' is defined for the type of that field, then we return
  2630.    that result.  */
  2631. tree
  2632. build_method_call (instance, name, parms, basetype_path, flags)
  2633.      tree instance, name, parms, basetype_path;
  2634.      int flags;
  2635. {
  2636.   register tree function, fntype, value_type;
  2637.   register tree basetype, save_basetype;
  2638.   register tree baselink, result, method_name, parmtypes, parm;
  2639.   tree last;
  2640.   int pass;
  2641.   enum visibility_type visibility;
  2642.  
  2643.   /* Range of cases for vtable optimization.  */
  2644.   enum vtable_needs { not_needed, maybe_needed, unneeded, needed };
  2645.   enum vtable_needs need_vtbl = not_needed;
  2646.  
  2647.   char *err_name;
  2648.   char *name_kind;
  2649.   int ever_seen = 0;
  2650.   tree instance_ptr = NULL_TREE;
  2651.   int all_virtual = flag_all_virtual;
  2652.   int static_call_context = 0;
  2653.   tree saw_private = NULL_TREE;
  2654.   tree saw_protected = NULL_TREE;
  2655.  
  2656.   /* Keep track of `const' and `volatile' objects.  */
  2657.   int constp, volatilep;
  2658.  
  2659. #ifdef GATHER_STATISTICS
  2660.   n_build_method_call++;
  2661. #endif
  2662.  
  2663.   if (instance == error_mark_node
  2664.       || name == error_mark_node
  2665.       || parms == error_mark_node
  2666.       || (instance != NULL_TREE && TREE_TYPE (instance) == error_mark_node))
  2667.     return error_mark_node;
  2668.  
  2669.   /* This is the logic that magically deletes the second argument to
  2670.      operator delete, if it is not needed. */
  2671.   if (name == ansi_opname[(int) DELETE_EXPR] && list_length (parms)==2)
  2672.     {
  2673.       tree save_last = TREE_CHAIN (parms);
  2674.       tree result;
  2675.       /* get rid of unneeded argument */
  2676.       TREE_CHAIN (parms) = NULL_TREE;
  2677.       result = build_method_call (instance, name, parms, basetype_path,
  2678.                   (LOOKUP_SPECULATIVELY|flags)
  2679.                   &~LOOKUP_COMPLAIN);
  2680.       /* If it works, return it. */
  2681.       if (result && result != error_mark_node)
  2682.     return build_method_call (instance, name, parms, basetype_path, flags);
  2683.       /* If it doesn't work, two argument delete must work */
  2684.       TREE_CHAIN (parms) = save_last;
  2685.     }
  2686.  
  2687.   if (TREE_CODE (name) == BIT_NOT_EXPR)
  2688.     {
  2689.       flags |= LOOKUP_DESTRUCTOR;
  2690.       name = TREE_OPERAND (name, 0);
  2691.       if (parms)
  2692.     error ("destructors take no parameters");
  2693.       basetype = IDENTIFIER_TYPE_VALUE (name);
  2694.       if (basetype == NULL_TREE)
  2695.     basetype = IDENTIFIER_CLASS_TYPE_VALUE (name);
  2696.       if (! TYPE_HAS_DESTRUCTOR (basetype))
  2697.     return void_zero_node;
  2698.       instance = default_conversion (instance);
  2699.       if (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE)
  2700.     instance_ptr = instance;
  2701.       else
  2702.     instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
  2703.       return build_delete (build_pointer_type (basetype),
  2704.                instance_ptr, integer_two_node,
  2705.                LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0);
  2706.     }
  2707.  
  2708.   /* Initialize name for error reporting.  */
  2709.   if (IDENTIFIER_TYPENAME_P (name))
  2710.     err_name = "type conversion operator";
  2711.   else if (IDENTIFIER_OPNAME_P (name))
  2712.     {
  2713.       char *p = operator_name_string (name);
  2714.       err_name = (char *)alloca (strlen (p) + 10);
  2715.       sprintf (err_name, "operator %s", p);
  2716.     }
  2717.   else if (TREE_CODE (name) == SCOPE_REF)
  2718.     err_name = IDENTIFIER_POINTER (TREE_OPERAND (name, 1));
  2719.   else
  2720.     err_name = IDENTIFIER_POINTER (name);
  2721.  
  2722.   if (IDENTIFIER_OPNAME_P (name))
  2723.     GNU_xref_call (current_function_decl,  IDENTIFIER_POINTER (name));
  2724.   else
  2725.     GNU_xref_call (current_function_decl, err_name);
  2726.  
  2727.   if (instance == NULL_TREE)
  2728.     {
  2729.       basetype = NULL_TREE;
  2730.       /* Check cases where this is really a call to raise
  2731.      an exception.  */
  2732.       if (current_class_type && TREE_CODE (name) == IDENTIFIER_NODE)
  2733.     {
  2734.       basetype = purpose_member (name, CLASSTYPE_TAGS (current_class_type));
  2735.       if (basetype)
  2736.         basetype = TREE_VALUE (basetype);
  2737.     }
  2738.       else if (TREE_CODE (name) == SCOPE_REF
  2739.            && TREE_CODE (TREE_OPERAND (name, 0)) == IDENTIFIER_NODE)
  2740.     {
  2741.       if (! is_aggr_typedef (TREE_OPERAND (name, 0), 1))
  2742.         return error_mark_node;
  2743.       basetype = purpose_member (TREE_OPERAND (name, 1),
  2744.                      CLASSTYPE_TAGS (IDENTIFIER_TYPE_VALUE (TREE_OPERAND (name, 0))));
  2745.       if (basetype)
  2746.         basetype = TREE_VALUE (basetype);
  2747.     }
  2748.  
  2749.       if (basetype != NULL_TREE)
  2750.     ;
  2751.       /* call to a constructor... */
  2752.       else if (IDENTIFIER_HAS_TYPE_VALUE (name))
  2753.     {
  2754.       basetype = IDENTIFIER_TYPE_VALUE (name);
  2755.       name = constructor_name_full (basetype);
  2756.     }
  2757.       else
  2758.     {
  2759.       tree typedef_name = lookup_name (name, 1);
  2760.       if (typedef_name && TREE_CODE (typedef_name) == TYPE_DECL)
  2761.         {
  2762.           /* Canonicalize the typedef name.  */
  2763.           basetype = TREE_TYPE (typedef_name);
  2764.           name = TYPE_IDENTIFIER (basetype);
  2765.         }
  2766.       else
  2767.         {
  2768.           cp_error ("no constructor named `%T' in visible scope",
  2769.             name);
  2770.           return error_mark_node;
  2771.         }
  2772.     }
  2773.  
  2774.       if (! IS_AGGR_TYPE (basetype))
  2775.     {
  2776.     non_aggr_error:
  2777.       if ((flags & LOOKUP_COMPLAIN) && TREE_CODE (basetype) != ERROR_MARK)
  2778.         error ("request for member `%s' in something not a structure or union", err_name);
  2779.  
  2780.       return error_mark_node;
  2781.     }
  2782.     }
  2783.   else if (instance == C_C_D || instance == current_class_decl)
  2784.     {
  2785.       /* When doing initialization, we side-effect the TREE_TYPE of
  2786.      C_C_D, hence we cannot set up BASETYPE from CURRENT_CLASS_TYPE.  */
  2787.       basetype = TREE_TYPE (C_C_D);
  2788.  
  2789.       /* Anything manifestly `this' in constructors and destructors
  2790.      has a known type, so virtual function tables are not needed.  */
  2791.       if (TYPE_VIRTUAL_P (basetype)
  2792.       && !(flags & LOOKUP_NONVIRTUAL))
  2793.     need_vtbl = (dtor_label || ctor_label)
  2794.       ? unneeded : maybe_needed;
  2795.  
  2796.       instance = C_C_D;
  2797.       instance_ptr = current_class_decl;
  2798.       result = build_field_call (TYPE_BINFO (current_class_type),
  2799.                  instance_ptr, name, parms, err_name);
  2800.  
  2801.       if (result)
  2802.     return result;
  2803.     }
  2804.   else if (TREE_CODE (instance) == RESULT_DECL)
  2805.     {
  2806.       basetype = TREE_TYPE (instance);
  2807.       /* Should we ever have to make a virtual function reference
  2808.      from a RESULT_DECL, know that it must be of fixed type
  2809.      within the scope of this function.  */
  2810.       if (!(flags & LOOKUP_NONVIRTUAL) && TYPE_VIRTUAL_P (basetype))
  2811.     need_vtbl = maybe_needed;
  2812.       instance_ptr = build1 (ADDR_EXPR, TYPE_POINTER_TO (basetype), instance);
  2813.     }
  2814.   else if (instance == current_exception_object)
  2815.     {
  2816.       instance_ptr = build1 (ADDR_EXPR, TYPE_POINTER_TO (current_exception_type),
  2817.                 TREE_OPERAND (current_exception_object, 0));
  2818.       mark_addressable (TREE_OPERAND (current_exception_object, 0));
  2819.       result = build_field_call (TYPE_BINFO (current_exception_type),
  2820.                  instance_ptr, name, parms, err_name);
  2821.       if (result)
  2822.     return result;
  2823.       error ("exception member `%s' cannot be invoked", err_name);
  2824.       return error_mark_node;
  2825.     }
  2826.   else
  2827.     {
  2828.       /* The MAIN_VARIANT of the type that `instance_ptr' winds up being.  */
  2829.       tree inst_ptr_basetype;
  2830.  
  2831.       static_call_context = (TREE_CODE (instance) == NOP_EXPR
  2832.                  && TREE_OPERAND (instance, 0) == error_mark_node);
  2833.  
  2834.       /* the base type of an instance variable is pointer to class */
  2835.       basetype = TREE_TYPE (instance);
  2836.  
  2837.       if (TREE_CODE (basetype) == REFERENCE_TYPE)
  2838.     {
  2839.       basetype = TYPE_MAIN_VARIANT (TREE_TYPE (basetype));
  2840.       if (! IS_AGGR_TYPE (basetype))
  2841.         goto non_aggr_error;
  2842.       /* Call to convert not needed because we are remaining
  2843.          within the same type.  */
  2844.       instance_ptr = build1 (NOP_EXPR, TYPE_POINTER_TO (basetype), instance);
  2845.       inst_ptr_basetype = basetype;
  2846.     }
  2847.       else
  2848.     {
  2849.       if (TREE_CODE (basetype) == POINTER_TYPE)
  2850.         {
  2851.           basetype = TREE_TYPE (basetype);
  2852.           instance_ptr = instance;
  2853.         }
  2854.  
  2855.       if (! IS_AGGR_TYPE (basetype))
  2856.         goto non_aggr_error;
  2857.  
  2858.       if (! instance_ptr)
  2859.         {
  2860.           if ((lvalue_p (instance)
  2861.            && (instance_ptr = build_unary_op (ADDR_EXPR, instance, 0)))
  2862.           || (instance_ptr = unary_complex_lvalue (ADDR_EXPR, instance)))
  2863.         {
  2864.           if (instance_ptr == error_mark_node)
  2865.             return error_mark_node;
  2866.         }
  2867.           else if (TREE_CODE (instance) == NOP_EXPR
  2868.                || TREE_CODE (instance) == CONSTRUCTOR)
  2869.         {
  2870.           /* A cast is not an lvalue.  Initialize a fresh temp
  2871.              with the value we are casting from, and proceed with
  2872.              that temporary.  We can't cast to a reference type,
  2873.              so that simplifies the initialization to something
  2874.              we can manage.  */
  2875.           tree temp = get_temp_name (TREE_TYPE (instance), 0);
  2876.           if (IS_AGGR_TYPE (TREE_TYPE (instance)))
  2877.             expand_aggr_init (temp, instance, 0);
  2878.           else
  2879.             {
  2880.               store_init_value (temp, instance);
  2881.               expand_decl_init (temp);
  2882.             }
  2883.           instance = temp;
  2884.           instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
  2885.         }
  2886.           else
  2887.         {
  2888.           if (TREE_CODE (instance) != CALL_EXPR)
  2889.             my_friendly_abort (125);
  2890.           if (TYPE_NEEDS_CONSTRUCTOR (basetype))
  2891.             instance = build_cplus_new (basetype, instance, 0);
  2892.           else
  2893.             {
  2894.               instance = get_temp_name (basetype, 0);
  2895.               TREE_ADDRESSABLE (instance) = 1;
  2896.             }
  2897.           instance_ptr = build_unary_op (ADDR_EXPR, instance, 0);
  2898.         }
  2899.           /* @@ Should we call comp_target_types here?  */
  2900.           inst_ptr_basetype = TREE_TYPE (TREE_TYPE (instance_ptr));
  2901.           if (TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (inst_ptr_basetype))
  2902.         basetype = inst_ptr_basetype;
  2903.           else
  2904.         {
  2905.           instance_ptr = convert (TYPE_POINTER_TO (basetype), instance_ptr);
  2906.           if (instance_ptr == error_mark_node)
  2907.             return error_mark_node;
  2908.         }
  2909.         }
  2910.       else
  2911.         inst_ptr_basetype = TREE_TYPE (TREE_TYPE (instance_ptr));
  2912.     }
  2913.  
  2914.       if (basetype_path == NULL_TREE)
  2915.     basetype_path = TYPE_BINFO (inst_ptr_basetype);
  2916.  
  2917.       result = build_field_call (basetype_path, instance_ptr, name, parms, err_name);
  2918.       if (result)
  2919.     return result;
  2920.  
  2921.       if (!(flags & LOOKUP_NONVIRTUAL) && TYPE_VIRTUAL_P (basetype))
  2922.     {
  2923.       if (TREE_SIDE_EFFECTS (instance_ptr))
  2924.         {
  2925.           /* This action is needed because the instance is needed
  2926.          for providing the base of the virtual function table.
  2927.          Without using a SAVE_EXPR, the function we are building
  2928.          may be called twice, or side effects on the instance
  2929.          variable (such as a post-increment), may happen twice.  */
  2930.           instance_ptr = save_expr (instance_ptr);
  2931.           instance = build_indirect_ref (instance_ptr, NULL_PTR);
  2932.         }
  2933.       else if (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE)
  2934.         {
  2935.           /* This happens when called for operator new ().  */
  2936.           instance = build_indirect_ref (instance, NULL_PTR);
  2937.         }
  2938.  
  2939.       need_vtbl = maybe_needed;
  2940.     }
  2941.     }
  2942.  
  2943.   if (TYPE_SIZE (basetype) == 0)
  2944.     {
  2945.       /* This is worth complaining about, I think.  */
  2946.       cp_error ("cannot lookup method in incomplete type `%T'", basetype);
  2947.       return error_mark_node;
  2948.     }
  2949.  
  2950.   save_basetype = basetype;
  2951.  
  2952. #if 0
  2953.   if (all_virtual == 1
  2954.       && (! strncmp (IDENTIFIER_POINTER (name), OPERATOR_METHOD_FORMAT,
  2955.              OPERATOR_METHOD_LENGTH)
  2956.       || instance_ptr == NULL_TREE
  2957.       || (TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype) == 0)))
  2958.     all_virtual = 0;
  2959. #endif
  2960.  
  2961.   last = NULL_TREE;
  2962.   for (parmtypes = NULL_TREE, parm = parms; parm; parm = TREE_CHAIN (parm))
  2963.     {
  2964.       tree t = TREE_TYPE (TREE_VALUE (parm));
  2965.       if (TREE_CODE (t) == OFFSET_TYPE)
  2966.     {
  2967.       /* Convert OFFSET_TYPE entities to their normal selves.  */
  2968.       TREE_VALUE (parm) = resolve_offset_ref (TREE_VALUE (parm));
  2969.       t = TREE_TYPE (TREE_VALUE (parm));
  2970.     }
  2971.       if (TREE_CODE (t) == ARRAY_TYPE)
  2972.     {
  2973.       /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place.
  2974.          This eliminates needless calls to `compute_conversion_costs'.  */
  2975.       TREE_VALUE (parm) = default_conversion (TREE_VALUE (parm));
  2976.       t = TREE_TYPE (TREE_VALUE (parm));
  2977.     }
  2978.       if (t == error_mark_node)
  2979.     return error_mark_node;
  2980.       last = build_tree_list (NULL_TREE, t);
  2981.       parmtypes = chainon (parmtypes, last);
  2982.     }
  2983.  
  2984.   if (instance)
  2985.     {
  2986.       constp = TREE_READONLY (instance);
  2987.       volatilep = TREE_THIS_VOLATILE (instance);
  2988.       parms = tree_cons (NULL_TREE, instance_ptr, parms);
  2989.     }
  2990.   else
  2991.     {
  2992.       /* Raw constructors are always in charge.  */
  2993.       if (TYPE_USES_VIRTUAL_BASECLASSES (basetype)
  2994.       && ! (flags & LOOKUP_HAS_IN_CHARGE))
  2995.     {
  2996.       flags |= LOOKUP_HAS_IN_CHARGE;
  2997.       parms = tree_cons (NULL_TREE, integer_one_node, parms);
  2998.       parmtypes = tree_cons (NULL_TREE, integer_type_node, parmtypes);
  2999.     }
  3000.  
  3001.       if (flag_this_is_variable > 0)
  3002.     {
  3003.       constp = 0;
  3004.       volatilep = 0;
  3005.       parms = tree_cons (NULL_TREE, build1 (NOP_EXPR, TYPE_POINTER_TO (basetype), integer_zero_node), parms);
  3006.     }
  3007.       else
  3008.     {
  3009.       constp = 0;
  3010.       volatilep = 0;
  3011.       instance_ptr = build_new (NULL_TREE, basetype, void_type_node, 0);
  3012.       if (instance_ptr == error_mark_node)
  3013.         return error_mark_node;
  3014.       instance_ptr = save_expr (instance_ptr);
  3015.       TREE_CALLS_NEW (instance_ptr) = 1;
  3016.       instance = build_indirect_ref (instance_ptr, NULL_PTR);
  3017.  
  3018.       /* If it's a default argument initialized from a ctor, what we get
  3019.          from instance_ptr will match the arglist for the FUNCTION_DECL
  3020.          of the constructor.  */
  3021.       if (parms && TREE_CODE (TREE_VALUE (parms)) == CALL_EXPR
  3022.           && TREE_OPERAND (TREE_VALUE (parms), 1)
  3023.           && TREE_CALLS_NEW (TREE_VALUE (TREE_OPERAND (TREE_VALUE (parms), 1))))
  3024.         parms = build_tree_list (NULL_TREE, instance_ptr);
  3025.       else
  3026.         parms = tree_cons (NULL_TREE, instance_ptr, parms);
  3027.     }
  3028.     }
  3029.   parmtypes = tree_cons (NULL_TREE,
  3030.              build_pointer_type (build_type_variant (basetype, constp, volatilep)),
  3031.              parmtypes);
  3032.   if (last == NULL_TREE)
  3033.     last = parmtypes;
  3034.  
  3035.   /* Look up function name in the structure type definition.  */
  3036.  
  3037.   if ((IDENTIFIER_HAS_TYPE_VALUE (name)
  3038.        && IS_AGGR_TYPE (IDENTIFIER_TYPE_VALUE (name)))
  3039.       || name == constructor_name (basetype))
  3040.     {
  3041.       tree tmp = NULL_TREE;
  3042.       if (IDENTIFIER_TYPE_VALUE (name) == basetype
  3043.       || name == constructor_name (basetype))
  3044.     tmp = TYPE_BINFO (basetype);
  3045.       else
  3046.     tmp = get_binfo (IDENTIFIER_TYPE_VALUE (name), basetype, 0);
  3047.       
  3048.       if (tmp != NULL_TREE)
  3049.     {
  3050.       name_kind = "constructor";
  3051.       
  3052.       if (TYPE_USES_VIRTUAL_BASECLASSES (basetype)
  3053.           && ! (flags & LOOKUP_HAS_IN_CHARGE))
  3054.         {
  3055.           /* Constructors called for initialization
  3056.          only are never in charge.  */
  3057.           tree tmplist;
  3058.           
  3059.           flags |= LOOKUP_HAS_IN_CHARGE;
  3060.           tmplist = tree_cons (NULL_TREE, integer_zero_node,
  3061.                    TREE_CHAIN (parms));
  3062.           TREE_CHAIN (parms) = tmplist;
  3063.           tmplist = tree_cons (NULL_TREE, integer_type_node, TREE_CHAIN (parmtypes));
  3064.           TREE_CHAIN (parmtypes) = tmplist;
  3065.         }
  3066.       basetype = BINFO_TYPE (tmp);
  3067.     }
  3068.       else
  3069.     name_kind = "method";
  3070.     }
  3071.   else
  3072.     name_kind = "method";
  3073.   
  3074.   if (basetype_path == NULL_TREE)
  3075.     basetype_path = TYPE_BINFO (basetype);
  3076.   result = lookup_fnfields (basetype_path, name,
  3077.                 (flags & LOOKUP_COMPLAIN));
  3078.   if (result == error_mark_node)
  3079.     return error_mark_node;
  3080.  
  3081.  
  3082.   /* Now, go look for this method name.  We do not find destructors here.
  3083.  
  3084.      Putting `void_list_node' on the end of the parmtypes
  3085.      fakes out `build_decl_overload' into doing the right thing.  */
  3086.   TREE_CHAIN (last) = void_list_node;
  3087.   method_name = build_decl_overload (name, parmtypes,
  3088.                      1 + (name == constructor_name (save_basetype)
  3089.                       || name == constructor_name_full (save_basetype)));
  3090.   TREE_CHAIN (last) = NULL_TREE;
  3091.  
  3092.   for (pass = 0; pass < 2; pass++)
  3093.     {
  3094.       struct candidate *candidates;
  3095.       struct candidate *cp;
  3096.       int len;
  3097.       unsigned best = 1;
  3098.  
  3099.       /* This increments every time we go up the type hierarchy.
  3100.      The idea is to prefer a function of the derived class if possible. */
  3101.       int b_or_d = 0;
  3102.  
  3103.       baselink = result;
  3104.  
  3105.       if (pass > 0)
  3106.     {
  3107.       candidates
  3108.         = (struct candidate *) alloca ((ever_seen+1)
  3109.                        * sizeof (struct candidate));
  3110.       bzero (candidates, (ever_seen + 1) * sizeof (struct candidate));
  3111.       cp = candidates;
  3112.       len = list_length (parms);
  3113.  
  3114.       /* First see if a global function has a shot at it.  */
  3115.       if (flags & LOOKUP_GLOBAL)
  3116.         {
  3117.           tree friend_parms;
  3118.           tree parm = TREE_VALUE (parms);
  3119.  
  3120.           if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE)
  3121.         friend_parms = parms;
  3122.           else if (TREE_CODE (TREE_TYPE (parm)) == POINTER_TYPE)
  3123.         {
  3124.           tree new_type;
  3125.           parm = build_indirect_ref (parm, "friendifying parms (compiler error)");
  3126.           new_type = build_reference_type (TREE_TYPE (parm));
  3127.           /* It is possible that this should go down a layer. */
  3128.           new_type = build_type_variant (new_type,
  3129.                          TREE_READONLY (parm),
  3130.                          TREE_THIS_VOLATILE (parm));
  3131.           parm = convert (new_type, parm);
  3132.           friend_parms = tree_cons (NULL_TREE, parm, TREE_CHAIN (parms));
  3133.         }
  3134.           else
  3135.         my_friendly_abort (167);
  3136.  
  3137.           if (flag_ansi_overloading)
  3138.         {
  3139.           cp->v.ansi_harshness
  3140.             = (struct harshness_code *)alloca ((len+1) * sizeof (struct harshness_code));
  3141.           cp->h_len = len;
  3142.         }
  3143.           else
  3144.         cp->v.old_harshness
  3145.           = (unsigned short *)alloca ((len+1) * sizeof (short));
  3146.  
  3147.           result = build_overload_call (name, friend_parms, 0, cp);
  3148.           /* If it turns out to be the one we were actually looking for
  3149.          (it was probably a friend function), the return the
  3150.          good result.  */
  3151.           if (TREE_CODE (result) == CALL_EXPR)
  3152.         return result;
  3153.  
  3154.           if (flag_ansi_overloading)
  3155.         while ((cp->h.code & EVIL_CODE) == 0)
  3156.           {
  3157.             /* non-standard uses: set the field to 0 to indicate
  3158.                we are using a non-member function.  */
  3159.             cp->u.field = 0;
  3160.             if (cp->v.ansi_harshness[len].distance == 0
  3161.             && cp->h.code < best)
  3162.               best = cp->h.code;
  3163.             cp += 1;
  3164.           }
  3165.           else
  3166.         while (cp->evil == 0)
  3167.           {
  3168.             /* non-standard uses: set the field to 0 to indicate
  3169.                we are using a non-member function.  */
  3170.             cp->u.field = 0;
  3171.             if (cp->v.old_harshness[len] == 0
  3172.             && cp->v.old_harshness[len] == 0
  3173.             && cp->ellipsis == 0 && cp->user == 0 && cp->b_or_d == 0
  3174.             && cp->easy < best)
  3175.               best = cp->easy;
  3176.             cp += 1;
  3177.           }
  3178.         }
  3179.     }
  3180.  
  3181.       while (baselink)
  3182.     {
  3183.       /* We have a hit (of sorts). If the parameter list is
  3184.          "error_mark_node", or some variant thereof, it won't
  3185.          match any methods.  Since we have verified that the is
  3186.          some method vaguely matching this one (in name at least),
  3187.          silently return.
  3188.          
  3189.          Don't stop for friends, however.  */
  3190.       tree basetypes = TREE_PURPOSE (baselink);
  3191.  
  3192.       function = TREE_VALUE (baselink);
  3193.       if (TREE_CODE (basetypes) == TREE_LIST)
  3194.         basetypes = TREE_VALUE (basetypes);
  3195.       basetype = BINFO_TYPE (basetypes);
  3196.  
  3197.       /* Cast the instance variable to the appropriate type.  */
  3198.       TREE_VALUE (parmtypes) = TYPE_POINTER_TO (basetype);
  3199.  
  3200.       if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (function)))
  3201.         function = DECL_CHAIN (function);
  3202.  
  3203.       for (; function; function = DECL_CHAIN (function))
  3204.         {
  3205. #ifdef GATHER_STATISTICS
  3206.           n_inner_fields_searched++;
  3207. #endif
  3208.           ever_seen++;
  3209.  
  3210.           /* Not looking for friends here.  */
  3211.           if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE
  3212.           && ! DECL_STATIC_FUNCTION_P (function))
  3213.         continue;
  3214.  
  3215.           if (pass == 0
  3216.           && DECL_ASSEMBLER_NAME (function) == method_name)
  3217.         {
  3218.           if (flags & LOOKUP_PROTECT)
  3219.             {
  3220.               visibility = compute_visibility (basetypes, function);
  3221.               if (visibility == visibility_protected
  3222.               && flags & LOOKUP_PROTECTED_OK)
  3223.             visibility = visibility_public;
  3224.             }
  3225.  
  3226.           if ((flags & LOOKUP_PROTECT) == 0
  3227.               || visibility == visibility_public)
  3228.             goto found_and_ok;
  3229.           else if (visibility == visibility_private)
  3230.             saw_private = function;
  3231.           else if (visibility == visibility_protected)
  3232.             saw_protected = function;
  3233.           /* If we fail on the exact match, we have
  3234.              an immediate failure.  */
  3235.           goto found;
  3236.         }
  3237.           if (pass > 0)
  3238.         {
  3239.           tree these_parms = parms;
  3240.  
  3241. #ifdef GATHER_STATISTICS
  3242.           n_inner_fields_searched++;
  3243. #endif
  3244.           if (flag_ansi_overloading)
  3245.             {
  3246.               cp->v.ansi_harshness
  3247.             = (struct harshness_code *)alloca ((len+1) * sizeof (struct harshness_code));
  3248.               cp->h_len = len;
  3249.             }
  3250.           else
  3251.             cp->v.old_harshness
  3252.               = (unsigned short *)alloca ((len+1) * sizeof (short));
  3253.  
  3254.           if (DECL_STATIC_FUNCTION_P (function))
  3255.             these_parms = TREE_CHAIN (these_parms);
  3256.           compute_conversion_costs (function, these_parms, cp, len);
  3257.  
  3258.           if (!flag_ansi_overloading)
  3259.               cp->b_or_d += b_or_d;
  3260.  
  3261.           if ((flag_ansi_overloading && (cp->h.code & EVIL_CODE) == 0)
  3262.               || (!flag_ansi_overloading && cp->evil == 0))
  3263.             {
  3264.               cp->u.field = function;
  3265.               cp->function = function;
  3266.               if (flags & LOOKUP_PROTECT)
  3267.             {
  3268.               enum visibility_type this_v;
  3269.               this_v = compute_visibility (basetypes, function);
  3270.               if (this_v == visibility_protected
  3271.                   && (flags & LOOKUP_PROTECTED_OK))
  3272.                 this_v = visibility_public;
  3273.               if (this_v != visibility_public)
  3274.                 {
  3275.                   if (this_v == visibility_private)
  3276.                 saw_private = function;
  3277.                   else
  3278.                 saw_protected = function;
  3279.                   continue;
  3280.                 }
  3281.             }
  3282.  
  3283.               /* No "two-level" conversions.  */
  3284.               if (flags & LOOKUP_NO_CONVERSION
  3285.               && ((flag_ansi_overloading
  3286.                    && (cp->h.code & USER_CODE))
  3287.                   || (!flag_ansi_overloading
  3288.                   && cp->user != 0)))
  3289.             continue;
  3290.  
  3291.               /* If we used default parameters, we must
  3292.              check to see whether anyone else might
  3293.              use them also, and report a possible
  3294.              ambiguity.  */
  3295.               if (! TYPE_USES_MULTIPLE_INHERITANCE (save_basetype)
  3296.               && ((flag_ansi_overloading
  3297.                    && cp->v.ansi_harshness[len].distance == 0
  3298.                    && cp->h.code < best)
  3299.                   || (!flag_ansi_overloading
  3300.                   && cp->v.old_harshness[len] == 0
  3301.                   && CONST_HARSHNESS (cp->v.old_harshness[0]) == 0
  3302.                   && cp->ellipsis == 0 && cp->user == 0 && cp->b_or_d == 0
  3303.                   && cp->easy < best)))
  3304.             {
  3305.               if (! DECL_STATIC_FUNCTION_P (function))
  3306.                 TREE_VALUE (parms) = cp->arg;
  3307.               if (best == 1)
  3308.                 goto found_and_maybe_warn;
  3309.             }
  3310.               cp++;
  3311.             }
  3312.         }
  3313.         }
  3314.       /* Now we have run through one link's member functions.
  3315.          arrange to head-insert this link's links.  */
  3316.       baselink = next_baselink (baselink);
  3317.       b_or_d += 1;
  3318.       /* Don't grab functions from base classes.  lookup_fnfield will
  3319.          do the work to get us down into the right place.  */
  3320.       baselink = NULL_TREE;
  3321.     }
  3322.       if (pass == 0)
  3323.     {
  3324.       tree igv = IDENTIFIER_GLOBAL_VALUE (name);
  3325.  
  3326.       /* No exact match could be found.  Now try to find match
  3327.          using default conversions.  */
  3328.       if ((flags & LOOKUP_GLOBAL) && igv)
  3329.         {
  3330.           if (TREE_CODE (igv) == FUNCTION_DECL)
  3331.         ever_seen += 1;
  3332.           else if (TREE_CODE (igv) == TREE_LIST)
  3333.         ever_seen += list_length (igv);
  3334.         }
  3335.  
  3336.       if (ever_seen == 0)
  3337.         {
  3338.           if ((flags & (LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN))
  3339.           == LOOKUP_SPECULATIVELY)
  3340.         return NULL_TREE;
  3341.           if (flags & LOOKUP_GLOBAL)
  3342.         error ("no global or non-hidden member function `%s' defined", err_name);
  3343.           else
  3344.         cp_error ("no non-hidden member function `%T::%s' defined", save_basetype, err_name);
  3345.           return error_mark_node;
  3346.         }
  3347.       continue;
  3348.     }
  3349.  
  3350.       if (cp - candidates != 0)
  3351.     {
  3352.       /* Rank from worst to best.  Then cp will point to best one.
  3353.          Private fields have their bits flipped.  For unsigned
  3354.          numbers, this should make them look very large.
  3355.          If the best alternate has a (signed) negative value,
  3356.          then all we ever saw were private members.  */
  3357.       if (cp - candidates > 1)
  3358.         {
  3359.           cp = ideal_candidate (save_basetype, candidates,
  3360.                     cp - candidates, parms, len);
  3361.           if (cp == (struct candidate *)0)
  3362.         {
  3363.           error ("ambiguous type conversion requested for %s `%s'",
  3364.              name_kind, err_name);
  3365.           return error_mark_node;
  3366.         }
  3367.           if ((flag_ansi_overloading && (cp->h.code & EVIL_CODE))
  3368.           || (!flag_ansi_overloading && cp->evil))
  3369.         return error_mark_node;
  3370.         }
  3371.       else if ((flag_ansi_overloading && (cp[-1].h.code & EVIL_CODE))
  3372.            || (!flag_ansi_overloading && cp[-1].evil == 2))
  3373.         {
  3374.           error ("ambiguous type conversion requested for %s `%s'",
  3375.              name_kind, err_name);
  3376.           return error_mark_node;
  3377.         }
  3378.       else
  3379.         cp--;
  3380.  
  3381.       /* The global function was the best, so use it.  */
  3382.       if (cp->u.field == 0)
  3383.         {
  3384.           /* We must convert the instance pointer into a reference type.
  3385.          Global overloaded functions can only either take
  3386.          aggregate objects (which come for free from references)
  3387.          or reference data types anyway.  */
  3388.           TREE_VALUE (parms) = copy_node (instance_ptr);
  3389.           TREE_TYPE (TREE_VALUE (parms)) = build_reference_type (TREE_TYPE (TREE_TYPE (instance_ptr)));
  3390.           return build_function_call (cp->function, parms);
  3391.         }
  3392.  
  3393.       function = cp->function;
  3394.       if (! DECL_STATIC_FUNCTION_P (function))
  3395.         TREE_VALUE (parms) = cp->arg;
  3396.       goto found_and_maybe_warn;
  3397.     }
  3398.  
  3399.       if ((flags & ~LOOKUP_GLOBAL) & (LOOKUP_COMPLAIN|LOOKUP_SPECULATIVELY))
  3400.     {
  3401.       char *tag_name, *buf;
  3402.  
  3403.       if ((flags & (LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN))
  3404.           == LOOKUP_SPECULATIVELY)
  3405.         return NULL_TREE;
  3406.  
  3407.       if (DECL_STATIC_FUNCTION_P (cp->function))
  3408.         parms = TREE_CHAIN (parms);
  3409.       if (ever_seen)
  3410.         {
  3411.           if (((HOST_WIDE_INT)saw_protected|(HOST_WIDE_INT)saw_private) == 0)
  3412.         {
  3413.           if (flags & LOOKUP_SPECULATIVELY)
  3414.             return NULL_TREE;
  3415.           if (static_call_context && TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)
  3416.             cp_error ("object missing in call to `%T::%s'",
  3417.                 TREE_TYPE (TREE_TYPE (instance_ptr)),
  3418.                 err_name);
  3419.           else
  3420.             report_type_mismatch (cp, parms, name_kind, err_name);
  3421.         }
  3422.           else
  3423.         {
  3424.           char buf[80];
  3425.           char *msg;
  3426.           tree seen = saw_private;
  3427.  
  3428.           if (saw_private)
  3429.             {
  3430.               if (saw_protected)
  3431.             msg = "%s `%%D' (and the like) are private or protected";
  3432.               else
  3433.             msg = "the %s `%%D' is private";
  3434.             }
  3435.           else
  3436.             {
  3437.               msg = "the %s `%%D' is protected";
  3438.               seen = saw_protected;
  3439.             }
  3440.           sprintf (buf, msg, name_kind);
  3441.           cp_error_at (buf, seen);
  3442.           error ("within this context");
  3443.         }
  3444.           return error_mark_node;
  3445.         }
  3446.  
  3447.       if ((flags & (LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN))
  3448.           == LOOKUP_COMPLAIN)
  3449.         {
  3450.           if (TREE_CODE (save_basetype) == RECORD_TYPE)
  3451.         tag_name = "structure";
  3452.           else
  3453.         tag_name = "union";
  3454.  
  3455.           /* FIXME: is this doing the right thing? */
  3456.           buf = (char *)alloca (30 + strlen (err_name));
  3457.           strcpy (buf, "%s has no method named `%s'");
  3458.           error (buf, tag_name, err_name);
  3459.           return error_mark_node;
  3460.         }
  3461.       return NULL_TREE;
  3462.     }
  3463.       continue;
  3464.  
  3465.     found_and_maybe_warn:
  3466.       if ((flag_ansi_overloading
  3467.        && (cp->v.ansi_harshness[0].code & CONST_CODE))
  3468.       || (!flag_ansi_overloading
  3469.           && CONST_HARSHNESS (cp->v.old_harshness[0])))
  3470.     {
  3471.       if (flags & LOOKUP_COMPLAIN)
  3472.         {
  3473.           cp_error_at ("non-const member function `%D'", cp->function);
  3474.           error ("called for const object at this point in file");
  3475.         }
  3476.       /* Not good enough for a match.  */
  3477.       else
  3478.         return error_mark_node;
  3479.     }
  3480.       goto found_and_ok;
  3481.     }
  3482.   /* Silently return error_mark_node.  */
  3483.   return error_mark_node;
  3484.  
  3485.  found:
  3486.   if (visibility == visibility_private)
  3487.     {
  3488.       if (flags & LOOKUP_COMPLAIN)
  3489.     {
  3490.       error_with_file_and_line (DECL_SOURCE_FILE (function),
  3491.                     DECL_SOURCE_LINE (function),
  3492.                     TREE_PRIVATE (function)
  3493.                     ? "%s `%s' is private"
  3494.                     : "%s `%s' is from private base class",
  3495.                     name_kind,
  3496.                     lang_printable_name (function));
  3497.       error ("within this context");
  3498.     }
  3499.       return error_mark_node;
  3500.     }
  3501.   else if (visibility == visibility_protected)
  3502.     {
  3503.       if (flags & LOOKUP_COMPLAIN)
  3504.     {
  3505.       error_with_file_and_line (DECL_SOURCE_FILE (function),
  3506.                     DECL_SOURCE_LINE (function),
  3507.                     TREE_PROTECTED (function)
  3508.                     ? "%s `%s' is protected"
  3509.                     : "%s `%s' has protected visibility from this point",
  3510.                     name_kind,
  3511.                     lang_printable_name (function));
  3512.       error ("within this context");
  3513.     }
  3514.       return error_mark_node;
  3515.     }
  3516.   my_friendly_abort (1);
  3517.  
  3518.  found_and_ok:
  3519.  
  3520.   /* From here on down, BASETYPE is the type that INSTANCE_PTR's
  3521.      type (if it exists) is a pointer to.  */
  3522.   function = DECL_MAIN_VARIANT (function);
  3523.   /* Declare external function if necessary. */
  3524.   assemble_external (function);
  3525.  
  3526.   fntype = TREE_TYPE (function);
  3527.   if (TREE_CODE (fntype) == POINTER_TYPE)
  3528.     fntype = TREE_TYPE (fntype);
  3529.   basetype = DECL_CLASS_CONTEXT (function);
  3530.  
  3531.   /* If we are referencing a virtual function from an object
  3532.      of effectively static type, then there is no need
  3533.      to go through the virtual function table.  */
  3534.   if (need_vtbl == maybe_needed)
  3535.     {
  3536.       int fixed_type = resolves_to_fixed_type_p (instance, 0);
  3537.  
  3538.       if (all_virtual == 1
  3539.       && DECL_VINDEX (function)
  3540.       && may_be_remote (basetype))
  3541.     need_vtbl = needed;
  3542.       else if (DECL_VINDEX (function))
  3543.     need_vtbl = fixed_type ? unneeded : needed;
  3544.       else
  3545.     need_vtbl = not_needed;
  3546.     }
  3547.  
  3548.   if (TREE_CODE (fntype) == METHOD_TYPE && static_call_context
  3549.       && !DECL_CONSTRUCTOR_P (function))
  3550.     {
  3551.       /* Let's be nice to the user for now, and give reasonable
  3552.      default behavior.  */
  3553.       instance_ptr = current_class_decl;
  3554.       if (instance_ptr)
  3555.     {
  3556.       if (basetype != current_class_type)
  3557.         {
  3558.           tree binfo = get_binfo (basetype, current_class_type, 1);
  3559.           if (binfo == NULL_TREE)
  3560.         {
  3561.           error_not_base_type (function, current_class_type);
  3562.           return error_mark_node;
  3563.         }
  3564.           else if (basetype == error_mark_node)
  3565.         return error_mark_node;
  3566.         }
  3567.     }
  3568.       /* Only allow a static member function to call another static member
  3569.      function.  */
  3570.       else if (DECL_LANG_SPECIFIC (function)
  3571.            && !DECL_STATIC_FUNCTION_P (function))
  3572.     {
  3573.       cp_error ("cannot call member function `%T::%s' without object",
  3574.               basetype, err_name);
  3575.       return error_mark_node;
  3576.     }
  3577.     }
  3578.  
  3579.   value_type = TREE_TYPE (fntype) ? TREE_TYPE (fntype) : void_type_node;
  3580.  
  3581.   if (TYPE_SIZE (value_type) == 0)
  3582.     {
  3583.       if (flags & LOOKUP_COMPLAIN)
  3584.     incomplete_type_error (0, value_type);
  3585.       return error_mark_node;
  3586.     }
  3587.  
  3588.   /* We do not pass FUNCTION into `convert_arguments', because by
  3589.      now everything should be ok.  If not, then we have a serious error.  */
  3590.   if (DECL_STATIC_FUNCTION_P (function))
  3591.     parms = convert_arguments (NULL_TREE, TYPE_ARG_TYPES (fntype),
  3592.                    TREE_CHAIN (parms), NULL_TREE, LOOKUP_NORMAL);
  3593.   else if (need_vtbl == unneeded)
  3594.     {
  3595.       int sub_flags = DECL_CONSTRUCTOR_P (function) ? flags : LOOKUP_NORMAL;
  3596.       basetype = TREE_TYPE (instance);
  3597.       if (TYPE_METHOD_BASETYPE (TREE_TYPE (function)) != TYPE_MAIN_VARIANT (basetype)
  3598.       && TYPE_USES_COMPLEX_INHERITANCE (basetype))
  3599.     {
  3600.       basetype = DECL_CLASS_CONTEXT (function);
  3601.       instance_ptr = convert_pointer_to (basetype, instance_ptr);
  3602.       instance = build_indirect_ref (instance_ptr, NULL_PTR);
  3603.     }
  3604.       parms = tree_cons (NULL_TREE, instance_ptr,
  3605.              convert_arguments (NULL_TREE, TREE_CHAIN (TYPE_ARG_TYPES (fntype)), TREE_CHAIN (parms), NULL_TREE, sub_flags));
  3606.     }
  3607.   else
  3608.     {
  3609.       if ((flags & LOOKUP_NONVIRTUAL) == 0)
  3610.     basetype = DECL_CONTEXT (function);
  3611.  
  3612.       /* First parm could be integer_zerop with casts like
  3613.      ((Object*)0)->Object::IsA()  */
  3614.       if (!integer_zerop (TREE_VALUE (parms)))
  3615.     {
  3616.       /* Since we can't have inheritance with a union, doing get_binfo
  3617.          on it won't work.  We do all the convert_pointer_to_real
  3618.          stuff to handle MI correctly...for unions, that's not
  3619.          an issue, so we must short-circuit that extra work here.  */
  3620.       tree tmp = TREE_TYPE (TREE_TYPE (TREE_VALUE (parms)));
  3621.       if (tmp != NULL_TREE && TREE_CODE (tmp) == UNION_TYPE)
  3622.         instance_ptr = TREE_VALUE (parms);
  3623.       else
  3624.         {
  3625.           tree binfo = get_binfo (basetype,
  3626.                       TREE_TYPE (TREE_TYPE (TREE_VALUE (parms))),
  3627.                       0);
  3628.           instance_ptr = convert_pointer_to_real (binfo, TREE_VALUE (parms));
  3629.         }
  3630.       instance_ptr
  3631.         = convert_pointer_to (build_type_variant (basetype,
  3632.                               constp, volatilep),
  3633.                   instance_ptr);
  3634.  
  3635.       if (TREE_CODE (instance_ptr) == COND_EXPR)
  3636.         {
  3637.           instance_ptr = save_expr (instance_ptr);
  3638.           instance = build_indirect_ref (instance_ptr, NULL_PTR);
  3639.         }
  3640.       else if (TREE_CODE (instance_ptr) == NOP_EXPR
  3641.            && TREE_CODE (TREE_OPERAND (instance_ptr, 0)) == ADDR_EXPR
  3642.            && TREE_OPERAND (TREE_OPERAND (instance_ptr, 0), 0) == instance)
  3643.         ;
  3644.       /* The call to `convert_pointer_to' may return error_mark_node.  */
  3645.       else if (TREE_CODE (instance_ptr) == ERROR_MARK)
  3646.         return instance_ptr;
  3647.       else if (instance == NULL_TREE
  3648.            || TREE_CODE (instance) != INDIRECT_REF
  3649.            || TREE_OPERAND (instance, 0) != instance_ptr)
  3650.         instance = build_indirect_ref (instance_ptr, NULL_PTR);
  3651.     }
  3652.       parms = tree_cons (NULL_TREE, instance_ptr,
  3653.              convert_arguments (NULL_TREE, TREE_CHAIN (TYPE_ARG_TYPES (fntype)), TREE_CHAIN (parms), NULL_TREE, LOOKUP_NORMAL));
  3654.     }
  3655.  
  3656. #if 0
  3657.   /* Constructors do not overload method calls.  */
  3658.   else if (TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype)
  3659.        && name != TYPE_IDENTIFIER (basetype)
  3660.        && (TREE_CODE (function) != FUNCTION_DECL
  3661.            || strncmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function)),
  3662.                OPERATOR_METHOD_FORMAT,
  3663.                OPERATOR_METHOD_LENGTH))
  3664.          && (may_be_remote (basetype) || instance != C_C_D))
  3665.     {
  3666.       tree fn_as_int;
  3667.  
  3668.       parms = TREE_CHAIN (parms);
  3669.  
  3670.       if (!all_virtual && TREE_CODE (function) == FUNCTION_DECL)
  3671.     fn_as_int = build_unary_op (ADDR_EXPR, function, 0);
  3672.       else
  3673.     fn_as_int = convert (TREE_TYPE (default_conversion (function)), DECL_VINDEX (function));
  3674.       if (all_virtual == 1)
  3675.     fn_as_int = convert (integer_type_node, fn_as_int);
  3676.  
  3677.       result = build_opfncall (METHOD_CALL_EXPR, LOOKUP_NORMAL, instance, fn_as_int, parms);
  3678.  
  3679.       if (result == NULL_TREE)
  3680.     {
  3681.       compiler_error ("could not overload `operator->()(...)'");
  3682.       return error_mark_node;
  3683.     }
  3684.       else if (result == error_mark_node)
  3685.     return error_mark_node;
  3686.  
  3687. #if 0
  3688.       /* Do this if we want the result of operator->() to inherit
  3689.      the type of the function it is subbing for.  */
  3690.       TREE_TYPE (result) = value_type;
  3691. #endif
  3692.  
  3693.       return result;
  3694.     }
  3695. #endif
  3696.  
  3697.   if (need_vtbl == needed)
  3698.     {
  3699.       function = build_vfn_ref (&TREE_VALUE (parms), instance, DECL_VINDEX (function));
  3700.       TREE_TYPE (function) = build_pointer_type (fntype);
  3701.     }
  3702.  
  3703.   if (TREE_CODE (function) == FUNCTION_DECL)
  3704.     GNU_xref_call (current_function_decl,
  3705.            IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function)));
  3706.  
  3707.   if (TREE_CODE (function) == FUNCTION_DECL)
  3708.     {
  3709.       if (DECL_INLINE (function))
  3710.     function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
  3711.       else
  3712.     {
  3713.       assemble_external (function);
  3714.       TREE_USED (function) = 1;
  3715.       function = default_conversion (function);
  3716.     }
  3717.     }
  3718.   else
  3719.     function = default_conversion (function);
  3720.  
  3721.   result = build_nt (CALL_EXPR, function, parms, NULL_TREE);
  3722.  
  3723.   TREE_TYPE (result) = value_type;
  3724.   TREE_SIDE_EFFECTS (result) = 1;
  3725.   TREE_RAISES (result)
  3726.     = TYPE_RAISES_EXCEPTIONS (fntype) || (parms && TREE_RAISES (parms));
  3727.   return result;
  3728. }
  3729.  
  3730. /* Similar to `build_method_call', but for overloaded non-member functions.
  3731.    The name of this function comes through NAME.  The name depends
  3732.    on PARMS.
  3733.  
  3734.    Note that this function must handle simple `C' promotions,
  3735.    as well as variable numbers of arguments (...), and
  3736.    default arguments to boot.
  3737.  
  3738.    If the overloading is successful, we return a tree node which
  3739.    contains the call to the function.
  3740.  
  3741.    If overloading produces candidates which are probable, but not definite,
  3742.    we hold these candidates.  If FINAL_CP is non-zero, then we are free
  3743.    to assume that final_cp points to enough storage for all candidates that
  3744.    this function might generate.  The `harshness' array is preallocated for
  3745.    the first candidate, but not for subsequent ones.
  3746.  
  3747.    Note that the DECL_RTL of FUNCTION must be made to agree with this
  3748.    function's new name.  */
  3749.  
  3750. tree
  3751. build_overload_call_real (fnname, parms, complain, final_cp, buildxxx)
  3752.      tree fnname, parms;
  3753.      int complain;
  3754.      struct candidate *final_cp;
  3755.      int buildxxx;
  3756. {
  3757.   /* must check for overloading here */
  3758.   tree overload_name, functions, function, parm;
  3759.   tree parmtypes = NULL_TREE, last = NULL_TREE;
  3760.   register tree outer;
  3761.   int length;
  3762.   int parmlength = list_length (parms);
  3763.  
  3764.   struct candidate *candidates, *cp;
  3765.  
  3766.   if (final_cp)
  3767.     {
  3768.       if (flag_ansi_overloading)
  3769.     {
  3770.       final_cp[0].h.code = 0;
  3771.       final_cp[0].h.distance = 0;
  3772.       final_cp[0].function = 0;
  3773.       /* end marker.  */
  3774.       final_cp[1].h.code = EVIL_CODE;
  3775.     }
  3776.       else
  3777.     {
  3778.       final_cp[0].evil = 0;
  3779.       final_cp[0].user = 0;
  3780.       final_cp[0].b_or_d = 0;
  3781.       final_cp[0].easy = 0;
  3782.       final_cp[0].function = 0;
  3783.       /* end marker.  */
  3784.       final_cp[1].evil = 1;
  3785.     }
  3786.     }
  3787.  
  3788.   for (parm = parms; parm; parm = TREE_CHAIN (parm))
  3789.     {
  3790.       register tree t = TREE_TYPE (TREE_VALUE (parm));
  3791.  
  3792.       if (t == error_mark_node)
  3793.     {
  3794.       if (final_cp)
  3795.         {
  3796.           if (flag_ansi_overloading)
  3797.         final_cp->h.code = EVIL_CODE;
  3798.           else
  3799.         final_cp->evil = 1;
  3800.         }
  3801.       return error_mark_node;
  3802.     }
  3803.       if (TREE_CODE (t) == ARRAY_TYPE || TREE_CODE (t) == OFFSET_TYPE)
  3804.     {
  3805.       /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place.
  3806.          Also convert OFFSET_TYPE entities to their normal selves.
  3807.          This eliminates needless calls to `compute_conversion_costs'.  */
  3808.       TREE_VALUE (parm) = default_conversion (TREE_VALUE (parm));
  3809.       t = TREE_TYPE (TREE_VALUE (parm));
  3810.     }
  3811.       last = build_tree_list (NULL_TREE, t);
  3812.       parmtypes = chainon (parmtypes, last);
  3813.     }
  3814.   if (last)
  3815.     TREE_CHAIN (last) = void_list_node;
  3816.   else
  3817.     parmtypes = void_list_node;
  3818.  
  3819.   if (! flag_ansi_overloading)
  3820.     {
  3821.       /* This is a speed improvement that ends up not working properly in
  3822.      the situation of fns with and without default parameters.  I turned
  3823.      this off in the new method so it'll go through the argument matching
  3824.      code to properly diagnose a match/failure. (bpk)  */
  3825.       overload_name = build_decl_overload (fnname, parmtypes, 0);
  3826.  
  3827.       /* Now check to see whether or not we can win.
  3828.      Note that if we are called from `build_method_call',
  3829.      then we cannot have a mis-match, because we would have
  3830.      already found such a winning case.  */
  3831.  
  3832.       if (IDENTIFIER_GLOBAL_VALUE (overload_name))
  3833.     if (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (overload_name)) != TREE_LIST)
  3834.       return build_function_call (DECL_MAIN_VARIANT (IDENTIFIER_GLOBAL_VALUE (overload_name)), parms);
  3835.     }
  3836.  
  3837.   functions = IDENTIFIER_GLOBAL_VALUE (fnname);
  3838.  
  3839.   if (functions == NULL_TREE)
  3840.     {
  3841.       if (complain)
  3842.     error ("only member functions apply");
  3843.       if (final_cp)
  3844.     {
  3845.       if (flag_ansi_overloading)
  3846.         final_cp->h.code = EVIL_CODE;
  3847.       else
  3848.         final_cp->evil = 1;
  3849.     }
  3850.       return error_mark_node;
  3851.     }
  3852.  
  3853.   if (TREE_CODE (functions) == FUNCTION_DECL)
  3854.     {
  3855.       functions = DECL_MAIN_VARIANT (functions);
  3856.       if (final_cp)
  3857.     {
  3858.       /* We are just curious whether this is a viable alternative or not.  */
  3859.       compute_conversion_costs (functions, parms, final_cp, parmlength);
  3860.       return functions;
  3861.     }
  3862.       else
  3863.     return build_function_call (functions, parms);
  3864.     }
  3865.  
  3866.   if (TREE_VALUE (functions) == NULL_TREE)
  3867.     {
  3868.       if (complain)
  3869.     cp_error ("function `%D' declared overloaded, but no instances of that function declared",
  3870.           TREE_PURPOSE (functions));
  3871.       if (final_cp)
  3872.     {
  3873.       if (flag_ansi_overloading)
  3874.         final_cp->h.code = EVIL_CODE;
  3875.       else
  3876.         final_cp->evil = 1;
  3877.     }
  3878.       return error_mark_node;
  3879.     }
  3880.  
  3881.   if (TREE_CODE (TREE_VALUE (functions)) == TREE_LIST)
  3882.     {
  3883.       register tree outer;
  3884.       length = 0;
  3885.  
  3886.       /* The list-of-lists should only occur for class things.  */
  3887.       my_friendly_assert (functions == IDENTIFIER_CLASS_VALUE (fnname), 168);
  3888.  
  3889.       for (outer = functions; outer; outer = TREE_CHAIN (outer))
  3890.     {
  3891.       /* member functions.  */
  3892.       length += decl_list_length (TREE_VALUE (TREE_VALUE (outer)));
  3893.       /* friend functions.  */
  3894.       length += list_length (TREE_TYPE (TREE_VALUE (outer)));
  3895.     }
  3896.     }
  3897.   else
  3898.     length = list_length (functions);
  3899.  
  3900.   if (final_cp)
  3901.     candidates = final_cp;
  3902.   else
  3903.     {
  3904.       candidates
  3905.     = (struct candidate *)alloca ((length+1) * sizeof (struct candidate));
  3906.       bzero (candidates, (length + 1) * sizeof (struct candidate));
  3907.     }
  3908.  
  3909.   cp = candidates;
  3910.  
  3911.   my_friendly_assert (TREE_CODE (TREE_VALUE (functions)) != TREE_LIST, 169);
  3912.  
  3913.   /* OUTER is the list of FUNCTION_DECLS, in a TREE_LIST.  */
  3914.   for (outer = functions; outer; outer = TREE_CHAIN (outer))
  3915.     {
  3916.       int template_cost = 0;
  3917.       function = TREE_VALUE (outer);
  3918.       if (TREE_CODE (function) != FUNCTION_DECL
  3919.       && ! (TREE_CODE (function) == TEMPLATE_DECL
  3920.         && ! DECL_TEMPLATE_IS_CLASS (function)
  3921.         && TREE_CODE (DECL_TEMPLATE_RESULT (function)) == FUNCTION_DECL))
  3922.     {
  3923.       enum tree_code code = TREE_CODE (function);
  3924.       if (code == TEMPLATE_DECL)
  3925.         code = TREE_CODE (DECL_TEMPLATE_RESULT (function));
  3926.       if (code == CONST_DECL)
  3927.         cp_error_at
  3928.           ("enumeral value `%D' conflicts with function of same name",
  3929.            function);
  3930.       else if (code == VAR_DECL)
  3931.         {
  3932.           if (TREE_STATIC (function))
  3933.         cp_error_at
  3934.           ("variable `%D' conflicts with function of same name",
  3935.            function);
  3936.           else
  3937.         cp_error_at
  3938.           ("constant field `%D' conflicts with function of same name",
  3939.            function);
  3940.         }
  3941.       else if (code == TYPE_DECL)
  3942.         continue;
  3943.       else
  3944.         my_friendly_abort (2);
  3945.       error ("at this point in file");
  3946.       continue;
  3947.     }
  3948.       if (TREE_CODE (function) == TEMPLATE_DECL)
  3949.     {
  3950.       int ntparms = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (function));
  3951.       tree *targs = (tree *) alloca (sizeof (tree) * ntparms);
  3952.       int i;
  3953.  
  3954.       i = type_unification (DECL_TEMPLATE_PARMS (function), targs,
  3955.                 TYPE_ARG_TYPES (TREE_TYPE (function)),
  3956.                 parms, &template_cost);
  3957.       if (i == 0)
  3958.         {
  3959.           struct candidate *cp2;
  3960.  
  3961.           function = instantiate_template (function, targs);
  3962.           /* Now check that the template instantiated for this is not
  3963.          the same as a function that's in the list due to some
  3964.          previous instantiation.  */
  3965.           cp2 = candidates;
  3966.           while (cp2 != cp)
  3967.         if (cp2->function == function)
  3968.           break;
  3969.         else
  3970.           cp2 += 1;
  3971.           if (cp2->function == function)
  3972.         continue;
  3973.         }
  3974.     }
  3975.  
  3976.       if (TREE_CODE (function) == TEMPLATE_DECL)
  3977.     {
  3978.       /* Unconverted template -- failed match.  */
  3979.       cp->function = function;
  3980.       cp->u.bad_arg = -4;
  3981.       if (flag_ansi_overloading)
  3982.         cp->h.code = EVIL_CODE;
  3983.       else
  3984.         cp->evil = 1;
  3985.     }
  3986.       else
  3987.     {
  3988.       function = DECL_MAIN_VARIANT (function);
  3989.  
  3990.       /* Can't use alloca here, since result might be
  3991.          passed to calling function.  */
  3992.       if (flag_ansi_overloading)
  3993.         {
  3994.           cp->v.ansi_harshness
  3995.         = (struct harshness_code *)oballoc ((parmlength+1) * sizeof (struct harshness_code));
  3996.           cp->h_len = parmlength;
  3997.         }
  3998.       else
  3999.         cp->v.old_harshness
  4000.           = (unsigned short *)oballoc ((parmlength+1) * sizeof (short));
  4001.  
  4002.       compute_conversion_costs (function, parms, cp, parmlength);
  4003.  
  4004.       if (flag_ansi_overloading)
  4005.         /* Make sure this is clear as well.  */
  4006.         cp->h.int_penalty += template_cost;
  4007.       else
  4008.         /* Should really add another field...  */
  4009.         cp->easy = cp->easy * 128 + template_cost;
  4010.  
  4011.       /* It seemed easier to have both if stmts in here, rather
  4012.          than excluding the hell out of it with flag_ansi_overloading
  4013.          everywhere. (bpk) */
  4014.       if (flag_ansi_overloading)
  4015.         {
  4016.           if ((cp[0].h.code & EVIL_CODE) == 0)
  4017.         {
  4018.           cp[1].h.code = EVIL_CODE;
  4019.  
  4020.           /* int_penalty is set by convert_harshness_ansi for cases
  4021.              where we need to know about any penalties that would
  4022.              otherwise make a TRIVIAL_CODE pass.  */
  4023.           if (final_cp
  4024.               && template_cost == 0
  4025.               && cp[0].h.code <= TRIVIAL_CODE
  4026.               && cp[0].h.int_penalty == 0)
  4027.             {
  4028.               final_cp[0].h = cp[0].h;
  4029.               return function;
  4030.             }
  4031.           cp++;
  4032.         }
  4033.         }
  4034.       else
  4035.         {
  4036.           if (cp[0].evil == 0)
  4037.         {
  4038.           cp[1].evil = 1;
  4039.           if (final_cp
  4040.               && cp[0].user == 0 && cp[0].b_or_d == 0
  4041.               && template_cost == 0
  4042.               && cp[0].easy <= 1)
  4043.             {
  4044.               final_cp[0].easy = cp[0].easy;
  4045.               return function;
  4046.             }
  4047.           cp++;
  4048.         }
  4049.         }
  4050.     }
  4051.     }
  4052.  
  4053.   if (cp - candidates)
  4054.     {
  4055.       tree rval = error_mark_node;
  4056.  
  4057.       /* Leave marker.  */
  4058.       if (flag_ansi_overloading)
  4059.     cp[0].h.code = EVIL_CODE;
  4060.       else
  4061.     cp[0].evil = 1;
  4062.       if (cp - candidates > 1)
  4063.     {
  4064.       struct candidate *best_cp
  4065.         = ideal_candidate (NULL_TREE, candidates,
  4066.                    cp - candidates, parms, parmlength);
  4067.       if (best_cp == (struct candidate *)0)
  4068.         {
  4069.           if (complain)
  4070.         cp_error ("call of overloaded `%D' is ambiguous", fnname);
  4071.           return error_mark_node;
  4072.         }
  4073.       else
  4074.         rval = best_cp->function;
  4075.     }
  4076.       else
  4077.     {
  4078.       cp -= 1;
  4079.       if ((flag_ansi_overloading && (cp->h.code & EVIL_CODE))
  4080.           || (!flag_ansi_overloading && cp->evil > 1))
  4081.         {
  4082.           if (complain)
  4083.         error ("type conversion ambiguous");
  4084.         }
  4085.       else
  4086.         rval = cp->function;
  4087.     }
  4088.  
  4089.       if (final_cp)
  4090.     return rval;
  4091.  
  4092.       return buildxxx ? build_function_call_maybe (rval, parms)
  4093.         : build_function_call (rval, parms);
  4094.     }
  4095.   else if (complain)
  4096.     report_type_mismatch (cp, parms, "function",
  4097.               decl_as_string (cp->function, 1));
  4098.  
  4099.   return error_mark_node;
  4100. }
  4101.  
  4102. tree
  4103. build_overload_call (fnname, parms, complain, final_cp)
  4104.      tree fnname, parms;
  4105.      int complain;
  4106.      struct candidate *final_cp;
  4107. {
  4108.   return build_overload_call_real (fnname, parms, complain, final_cp, 0);
  4109. }
  4110.  
  4111. tree
  4112. build_overload_call_maybe (fnname, parms, complain, final_cp)
  4113.      tree fnname, parms;
  4114.      int complain;
  4115.      struct candidate *final_cp;
  4116. {
  4117.   return build_overload_call_real (fnname, parms, complain, final_cp, 1);
  4118. }
  4119.